package BitSet;
import instrumentation.TrackerCoverage;
import junit.framework.*;

public class RandoopTest0 extends TestCase {
	public static TrackerCoverage track=  TrackerCoverage.getTracker();
  public static boolean debug = false;

  public void test1() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test1");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    java.lang.Object var4 = var0.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var4);
//	 track.calculateFitness(null);
//	 track.summarizeCoverage();
//	 System.out.print(track.toString());
//	 System.out.println(track.getConditionTargetId(100));
//	 track.reset();
//	 System.out.print(track.toString());
  }

  public void test2() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test2");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      int var8 = var3.nextClearBit((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);

  }

  public void test3() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test3");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    var0.set(0, 1);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      int var15 = var0.nextClearBit((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);

  }

  public void test4() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test4");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    boolean var14 = var8.get(100);
    int var15 = var8.size();
    int var16 = var8.cardinality();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var8.set(54, 10, false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 1);

  }

  public void test5() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test5");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    boolean var14 = var8.get(100);
    int var15 = var8.size();
    java.lang.Object var16 = var8.clone();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      int var18 = var8.nextClearBit((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var16);

  }

  public void test6() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test6");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.clear(1, 100);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(100, (-1), false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);

  }

  public void test7() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test7");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(64, 100);
    int var13 = var9.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 100);

  }

  public void test8() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test8");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.clear(1, 100);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(54, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);

  }

  public void test9() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test9");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var4 = var0.nextClearBit(0);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(10, 1, false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == 0);

  }

  public void test10() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test10");


    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var1 = new BitSet((-1));
      fail("Expected exception of type java.lang.NegativeArraySizeException");
    } catch (java.lang.NegativeArraySizeException e) {
      // Expected exception.
    }

  }

  public void test11() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test11");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    int var13 = var9.cardinality();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var9.flip(1, 0);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 54);

  }

  public void test12() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test12");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    boolean var14 = var8.get(100);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var17 = var8.get((-1), (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);

  }

  public void test13() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test13");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var0.set(100, false);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      boolean var15 = var0.get((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);

  }

  public void test14() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test14");


    BitSet var0 = new BitSet();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(100, 54);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }

  }

  public void test15() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test15");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    int var15 = var0.cardinality();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 1);

  }

  public void test16() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test16");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(64, 100);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      boolean var14 = var9.get((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);

  }

  public void test17() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test17");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(54, 54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);

  }

  public void test18() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test18");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var6.set((-1), (-1), true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);

  }

  public void test19() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test19");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var11 = var0.isEmpty();
    var0.set(10, 100);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      int var16 = var0.nextSetBit((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);

  }

  public void test20() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test20");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    int var13 = var0.cardinality();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(10, 1, true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 0);

  }

  public void test21() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test21");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    var35.flip(1);
    boolean var41 = var35.get(100);
    int var43 = var35.nextSetBit(1);
    var20.xor(var35);
    var0.andNot(var35);
    java.lang.String var46 = var0.toString();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear((-1), 54);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var46 + "' != '" + "{64}"+ "'", var46.equals("{64}"));

  }

  public void test22() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test22");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set((-1), 128, true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);

  }

  public void test23() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test23");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var8.size();
    var8.flip(0, 10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);

  }

  public void test24() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test24");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    BitSet var15 = var0.get(1, 100);
    java.lang.String var16 = var15.toString();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var16 + "' != '" + "{}"+ "'", var16.equals("{}"));

  }

  public void test25() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test25");


    BitSet var0 = new BitSet();
    var0.set(10, true);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }

  }

  public void test26() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test26");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    boolean var14 = var8.get(100);
    int var15 = var8.size();
    java.lang.Object var16 = var8.clone();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var8.flip((-1), 54);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var16);

  }

  public void test27() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test27");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var4.get(54);
    var4.set(64, true);
    int var17 = var4.nextSetBit(54);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var4.flip((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 64);

  }

  public void test28() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test28");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    int var13 = var2.size();
    var0.or(var2);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.flip((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 64);

  }

  public void test29() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test29");


    BitSet var1 = new BitSet(54);
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    BitSet var5 = new BitSet();
    var2.xor(var5);
    boolean var8 = var5.equals((java.lang.Object)(-1L));
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    int var24 = var9.cardinality();
    boolean var25 = var5.intersects(var9);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var29 = var26.length();
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    var30.set(100, true);
    boolean var36 = var26.intersects(var30);
    boolean var38 = var30.get(54);
    var30.set(64, true);
    int var43 = var30.nextSetBit(54);
    int var44 = var30.size();
    boolean var45 = var9.intersects(var30);
    var1.andNot(var30);
    java.lang.String var47 = var30.toString();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var47 + "' != '" + "{64, 100}"+ "'", var47.equals("{64, 100}"));

  }

  public void test30() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test30");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear((-1), 0);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);

  }

  public void test31() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test31");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var0.set(100, false);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    BitSet var17 = new BitSet();
    var14.xor(var17);
    boolean var20 = var17.equals((java.lang.Object)(-1L));
    var0.andNot(var17);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.flip(64, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);

  }

  public void test32() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test32");


    BitSet var0 = new BitSet();
    int var2 = var0.nextClearBit(100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == 100);

  }

  public void test33() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test33");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    int var13 = var2.size();
    var0.or(var2);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      int var16 = var0.nextClearBit((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 64);

  }

  public void test34() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test34");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var8.size();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var14 = var8.get(100, 10);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);

  }

  public void test35() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test35");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var4.get(54);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var15 = var4.get(10, 0);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);

  }

  public void test36() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test36");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(64, 100);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var9.clear((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);

  }

  public void test37() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test37");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    int var15 = var0.nextClearBit(0);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(10, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);

  }

  public void test38() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test38");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var13.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);

  }

  public void test39() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test39");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    int var12 = var0.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 64);

  }

  public void test40() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test40");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    int var13 = var0.cardinality();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var16 = var0.get(128, 2);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 0);

  }

  public void test41() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test41");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.clear(1, 100);
    var0.andNot(var13);
    var0.set(64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);

  }

  public void test42() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test42");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    var0.clear(1, 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);

  }

  public void test43() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test43");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var24.equals((java.lang.Object)(-1L));
    var18.or(var24);
    boolean var38 = var0.intersects(var24);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var24.clear(100, 54);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);

  }

  public void test44() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test44");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      int var6 = var3.nextClearBit((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);

  }

  public void test45() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test45");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var18 = var0.isEmpty();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    int var22 = var19.length();
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    var23.set(100, true);
    boolean var29 = var19.intersects(var23);
    int var30 = var19.size();
    var0.xor(var19);
    var0.flip(64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 64);

  }

  public void test46() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test46");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    boolean var14 = var2.equals((java.lang.Object)(-1L));
    var2.flip(0);
    BitSet var19 = var2.get(64, 100);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    int var23 = var20.length();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    boolean var30 = var20.intersects(var24);
    boolean var31 = var19.intersects(var24);
    var0.and(var19);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(10, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var19);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);

  }

  public void test47() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test47");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear(100);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set((-1), 64);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);

  }

  public void test48() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test48");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    BitSet var33 = new BitSet();
    var30.xor(var33);
    var25.and(var33);
    var33.flip(1);
    boolean var39 = var33.get(100);
    int var41 = var33.nextSetBit(1);
    var18.xor(var33);
    boolean var43 = var4.intersects(var33);
    var33.clear(10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);

  }

  public void test49() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test49");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    int var28 = var9.length();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var9.set(100, 2, true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == 64);

  }

  public void test50() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test50");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.set(0, true);
    int var23 = var13.nextSetBit(64);
    BitSet var25 = new BitSet(10);
    var13.or(var25);
    boolean var27 = var0.intersects(var13);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    boolean var39 = var28.isEmpty();
    int var40 = var28.size();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    int var44 = var41.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    boolean var51 = var41.intersects(var45);
    boolean var52 = var41.isEmpty();
    var41.set(10, 100);
    var28.xor(var41);
    int var58 = var28.nextClearBit(10);
    boolean var59 = var13.intersects(var28);
    BitSet var60 = new BitSet();
    boolean var62 = var60.get(0);
    BitSet var63 = new BitSet();
    var60.xor(var63);
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    BitSet var68 = new BitSet();
    var65.xor(var68);
    var60.and(var68);
    var60.set(10);
    boolean var73 = var28.equals((java.lang.Object)var60);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var76 = var60.get(100, 0);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);

  }

  public void test51() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test51");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    int var12 = var0.size();
    var0.set(0, true);
    int var16 = var0.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 64);

  }

  public void test52() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test52");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var21.set(100, 2, true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);

  }

  public void test53() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test53");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    var20.and(var28);
    var28.flip(1);
    boolean var34 = var28.get(100);
    int var35 = var28.size();
    int var36 = var28.cardinality();
    var6.xor(var28);
    java.lang.String var38 = var28.toString();
    int var40 = var28.nextClearBit(10);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var43 = var28.get(10, 2);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var38 + "' != '" + "{1}"+ "'", var38.equals("{1}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 10);

  }

  public void test54() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test54");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var8.set(128, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);

  }

  public void test55() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test55");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var19 = var0.get(54);
    var0.flip(1);
    java.lang.Object var22 = var0.clone();
    boolean var24 = var0.get(0);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(101, 100);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var22);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == true);

  }

  public void test56() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test56");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    int var14 = var0.nextClearBit(64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == 64);

  }

  public void test57() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test57");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    int var18 = var15.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    var19.set(100, true);
    boolean var25 = var15.intersects(var19);
    boolean var27 = var15.equals((java.lang.Object)(-1L));
    var15.flip(0);
    BitSet var32 = var15.get(64, 100);
    var0.or(var15);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    int var45 = var38.cardinality();
    var0.xor(var38);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(64, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var32);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);

  }

  public void test58() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test58");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    BitSet var33 = new BitSet();
    var30.xor(var33);
    var25.and(var33);
    var33.flip(1);
    boolean var39 = var33.get(100);
    int var41 = var33.nextSetBit(1);
    var18.xor(var33);
    boolean var43 = var4.intersects(var33);
    boolean var44 = var33.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);

  }

  public void test59() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test59");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.set(64);
    boolean var27 = var3.get(128);
    boolean var29 = var3.equals((java.lang.Object)' ');
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
  }

  public void test60() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test60");


    BitSet var1 = new BitSet(54);
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    BitSet var5 = new BitSet();
    var2.xor(var5);
    boolean var8 = var5.equals((java.lang.Object)(-1L));
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    int var24 = var9.cardinality();
    boolean var25 = var5.intersects(var9);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var29 = var26.length();
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    var30.set(100, true);
    boolean var36 = var26.intersects(var30);
    boolean var38 = var30.get(54);
    var30.set(64, true);
    int var43 = var30.nextSetBit(54);
    int var44 = var30.size();
    boolean var45 = var9.intersects(var30);
    var1.andNot(var30);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var30.set((-1), 128);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);

  }

  public void test61() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test61");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.set(0, true);
    int var23 = var13.nextSetBit(64);
    BitSet var25 = new BitSet(10);
    var13.or(var25);
    boolean var27 = var0.intersects(var13);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    boolean var39 = var28.isEmpty();
    int var40 = var28.size();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    int var44 = var41.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    boolean var51 = var41.intersects(var45);
    boolean var52 = var41.isEmpty();
    var41.set(10, 100);
    var28.xor(var41);
    int var58 = var28.nextClearBit(10);
    boolean var59 = var13.intersects(var28);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var28.flip(54, 0);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);

  }

  public void test62() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test62");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    int var5 = var0.length();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set((-1), false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 2);

  }

  public void test63() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test63");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    var9.clear();
    java.lang.String var14 = var9.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    boolean var21 = var18.equals((java.lang.Object)(-1L));
    BitSet var24 = var18.get(0, 1);
    var9.xor(var18);
    var9.flip(1, 100);
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    BitSet var32 = new BitSet();
    var29.xor(var32);
    var9.or(var29);
    var9.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);

  }

  public void test64() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test64");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    var0.clear(64);
    var0.set(2, 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);

  }

  public void test65() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test65");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    var35.flip(1);
    boolean var41 = var35.get(100);
    int var43 = var35.nextSetBit(1);
    var20.xor(var35);
    var0.andNot(var35);
    java.lang.String var46 = var0.toString();
    BitSet var49 = var0.get(2, 101);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(64, 0);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var46 + "' != '" + "{64}"+ "'", var46.equals("{64}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var49);

  }

  public void test66() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test66");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    int var18 = var15.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    var19.set(100, true);
    boolean var25 = var15.intersects(var19);
    boolean var27 = var15.equals((java.lang.Object)(-1L));
    var15.flip(0);
    BitSet var32 = var15.get(64, 100);
    var0.or(var15);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    int var45 = var38.cardinality();
    var0.xor(var38);
    BitSet var47 = new BitSet();
    int var48 = var47.length();
    BitSet var49 = new BitSet();
    boolean var51 = var49.get(0);
    int var52 = var49.length();
    BitSet var53 = new BitSet();
    boolean var55 = var53.get(0);
    var53.set(100, true);
    boolean var59 = var49.intersects(var53);
    int var60 = var49.size();
    var47.or(var49);
    boolean var62 = var38.intersects(var49);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var32);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);

  }

  public void test67() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test67");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    java.lang.String var28 = var21.toString();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var21.set((-1), 10, true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var28 + "' != '" + "{1}"+ "'", var28.equals("{1}"));

  }

  public void test68() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test68");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    boolean var14 = var8.get(100);
    int var16 = var8.nextSetBit(1);
    var8.flip(0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 1);

  }

  public void test69() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test69");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var3.clear((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);

  }

  public void test70() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test70");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    var35.flip(1);
    boolean var41 = var35.get(100);
    int var43 = var35.nextSetBit(1);
    var20.xor(var35);
    var0.andNot(var35);
    java.lang.String var46 = var0.toString();
    BitSet var49 = var0.get(2, 101);
    boolean var50 = var49.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var46 + "' != '" + "{64}"+ "'", var46.equals("{64}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var49);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);

  }

  public void test71() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test71");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    var0.set(100, false);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(101, 100);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);

  }

  public void test72() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test72");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    int var16 = var0.nextClearBit(0);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(100, 0);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 1);

  }

  public void test73() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test73");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var9.set(10, (-1), true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);

  }

  public void test74() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test74");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var18 = var0.isEmpty();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    int var22 = var19.length();
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    var23.set(100, true);
    boolean var29 = var19.intersects(var23);
    int var30 = var19.size();
    var0.xor(var19);
    boolean var32 = var19.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == true);

  }

  public void test75() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test75");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    boolean var29 = var26.equals((java.lang.Object)(-1L));
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    boolean var42 = var30.equals((java.lang.Object)(-1L));
    var30.flip(0);
    int var45 = var30.cardinality();
    boolean var46 = var26.intersects(var30);
    var0.and(var30);
    java.lang.String var48 = var0.toString();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set((-1), true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var48 + "' != '" + "{}"+ "'", var48.equals("{}"));

  }

  public void test76() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test76");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.clear(1, 100);
    var0.andNot(var13);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var25 = var0.get(101, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);

  }

  public void test77() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test77");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    var20.and(var28);
    var28.flip(1);
    boolean var34 = var28.get(100);
    int var35 = var28.size();
    int var36 = var28.cardinality();
    var6.xor(var28);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.flip(1);
    int var43 = var38.length();
    int var44 = var38.cardinality();
    boolean var45 = var6.intersects(var38);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var6.flip(101, 2);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == true);

  }

  public void test78() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test78");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.flip(10, 2);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);

  }

  public void test79() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test79");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    java.lang.Object var15 = var0.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);

  }

  public void test80() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test80");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    var0.flip(0);
    int var5 = var0.nextSetBit(128);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      int var7 = var0.nextSetBit((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == (-1));

  }

  public void test81() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test81");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);

  }

  public void test82() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test82");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.set(0, true);
    int var23 = var13.nextSetBit(64);
    BitSet var25 = new BitSet(10);
    var13.or(var25);
    boolean var27 = var0.intersects(var13);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    boolean var39 = var28.isEmpty();
    int var40 = var28.size();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    int var44 = var41.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    boolean var51 = var41.intersects(var45);
    boolean var52 = var41.isEmpty();
    var41.set(10, 100);
    var28.xor(var41);
    int var58 = var28.nextClearBit(10);
    boolean var59 = var13.intersects(var28);
    BitSet var60 = new BitSet();
    boolean var62 = var60.get(0);
    BitSet var63 = new BitSet();
    var60.xor(var63);
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    BitSet var68 = new BitSet();
    var65.xor(var68);
    var60.and(var68);
    var60.set(10);
    boolean var73 = var28.equals((java.lang.Object)var60);
    BitSet var76 = var28.get(10, 101);
    BitSet var77 = new BitSet();
    boolean var79 = var77.get(0);
    var77.set(100, true);
    BitSet var83 = new BitSet();
    boolean var85 = var83.get(0);
    int var86 = var83.length();
    BitSet var87 = new BitSet();
    boolean var89 = var87.get(0);
    var87.set(100, true);
    boolean var93 = var83.intersects(var87);
    boolean var94 = var77.intersects(var87);
    boolean var95 = var76.equals((java.lang.Object)var87);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var76);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var79 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var86 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var89 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var93 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var94 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var95 == false);

  }

  public void test83() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test83");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var0.set(100, false);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    BitSet var17 = new BitSet();
    var14.xor(var17);
    boolean var20 = var17.equals((java.lang.Object)(-1L));
    var0.andNot(var17);
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    boolean var31 = var28.equals((java.lang.Object)(-1L));
    BitSet var34 = var28.get(0, 1);
    var34.flip(10, 64);
    int var38 = var34.cardinality();
    var22.xor(var34);
    var0.xor(var34);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(10, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var34);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == 54);

  }

  public void test84() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test84");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var17 = var0.get(101, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);

  }

  public void test85() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test85");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    int var16 = var13.length();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    var17.set(0, true);
    var13.andNot(var17);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var39 = var27.equals((java.lang.Object)(-1L));
    var27.flip(0);
    BitSet var44 = var27.get(64, 100);
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    int var48 = var45.length();
    BitSet var49 = new BitSet();
    boolean var51 = var49.get(0);
    var49.set(100, true);
    boolean var55 = var45.intersects(var49);
    boolean var56 = var44.intersects(var49);
    boolean var57 = var13.equals((java.lang.Object)var44);
    int var59 = var13.nextSetBit(128);
    var10.or(var13);
    boolean var61 = var3.intersects(var10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var44);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);

  }

  public void test86() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test86");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var4.clear(1, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);

  }

  public void test87() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test87");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    boolean var7 = var0.equals((java.lang.Object)'a');
    boolean var8 = var0.isEmpty();
    boolean var10 = var0.get(128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);

  }

  public void test88() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test88");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.set(1, 100);
    var8.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);

  }

  public void test89() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test89");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.set(64, false);
    BitSet var17 = new BitSet();
    int var18 = var17.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    int var22 = var19.length();
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    var23.set(100, true);
    boolean var29 = var19.intersects(var23);
    int var30 = var19.size();
    var17.or(var19);
    var17.clear();
    var17.clear();
    var0.andNot(var17);
    var17.clear(1, 10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 64);

  }

  public void test90() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test90");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    int var13 = var0.cardinality();
    boolean var14 = var0.isEmpty();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    var15.set(100, true);
    boolean var22 = var15.equals((java.lang.Object)'a');
    boolean var23 = var0.equals((java.lang.Object)var22);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);

  }

  public void test91() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test91");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    int var18 = var15.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    var19.set(100, true);
    boolean var25 = var15.intersects(var19);
    boolean var27 = var15.equals((java.lang.Object)(-1L));
    var15.flip(0);
    BitSet var32 = var15.get(64, 100);
    var0.or(var15);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    int var45 = var38.cardinality();
    var0.xor(var38);
    int var47 = var0.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var32);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == 2);

  }

  public void test92() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test92");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var4 = var0.nextClearBit(0);
    java.lang.Object var5 = var0.clone();
    var0.flip(54);
    BitSet var9 = new BitSet(54);
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    BitSet var13 = new BitSet();
    var10.xor(var13);
    boolean var16 = var13.equals((java.lang.Object)(-1L));
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    int var20 = var17.length();
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    var21.set(100, true);
    boolean var27 = var17.intersects(var21);
    boolean var29 = var17.equals((java.lang.Object)(-1L));
    var17.flip(0);
    int var32 = var17.cardinality();
    boolean var33 = var13.intersects(var17);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    boolean var46 = var38.get(54);
    var38.set(64, true);
    int var51 = var38.nextSetBit(54);
    int var52 = var38.size();
    boolean var53 = var17.intersects(var38);
    var9.andNot(var38);
    var0.or(var9);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var9.set((-1), 101, false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var5);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);

  }

  public void test93() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test93");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    var15.and(var23);
    var0.or(var23);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    boolean var33 = var30.equals((java.lang.Object)(-1L));
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    boolean var46 = var34.equals((java.lang.Object)(-1L));
    var34.flip(0);
    int var49 = var34.cardinality();
    boolean var50 = var30.intersects(var34);
    int var51 = var30.size();
    int var52 = var30.size();
    boolean var53 = var23.equals((java.lang.Object)var30);
    int var55 = var23.nextClearBit(10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 10);

  }

  public void test94() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test94");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.set(64, false);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(100, 0, true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);

  }

  public void test95() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test95");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    BitSet var15 = var0.get(1, 100);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    BitSet var24 = new BitSet();
    var21.xor(var24);
    var16.and(var24);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    boolean var38 = var16.intersects(var27);
    var0.xor(var16);
    int var40 = var0.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 64);

  }

  public void test96() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test96");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    BitSet var15 = var0.get(1, 100);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.flip(65, 10);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);

  }

  public void test97() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test97");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(64, 100);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var9.set((-1), true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);

  }

  public void test98() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test98");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    boolean var10 = var3.isEmpty();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    int var14 = var11.length();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    var15.set(100, true);
    boolean var21 = var11.intersects(var15);
    int var22 = var11.size();
    java.lang.Object var23 = var11.clone();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    var24.set(0, true);
    int var34 = var24.nextSetBit(64);
    BitSet var36 = new BitSet(10);
    var24.or(var36);
    boolean var38 = var11.intersects(var24);
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    BitSet var42 = new BitSet();
    var39.xor(var42);
    BitSet var44 = new BitSet();
    boolean var46 = var44.get(0);
    BitSet var47 = new BitSet();
    var44.xor(var47);
    var39.and(var47);
    boolean var50 = var39.isEmpty();
    int var51 = var39.size();
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    int var55 = var52.length();
    BitSet var56 = new BitSet();
    boolean var58 = var56.get(0);
    var56.set(100, true);
    boolean var62 = var52.intersects(var56);
    boolean var63 = var52.isEmpty();
    var52.set(10, 100);
    var39.xor(var52);
    int var69 = var39.nextClearBit(10);
    boolean var70 = var24.intersects(var39);
    BitSet var71 = new BitSet();
    boolean var73 = var71.get(0);
    BitSet var74 = new BitSet();
    var71.xor(var74);
    BitSet var76 = new BitSet();
    boolean var78 = var76.get(0);
    BitSet var79 = new BitSet();
    var76.xor(var79);
    var71.and(var79);
    var71.set(10);
    boolean var84 = var39.equals((java.lang.Object)var71);
    boolean var85 = var3.equals((java.lang.Object)var71);
    int var87 = var3.nextSetBit(54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var23);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var78 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var87 == (-1));

  }

  public void test99() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test99");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var11 = var0.isEmpty();
    var0.set(10, 100);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.flip(100, 54);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
  }

  public void test100() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test100");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    int var5 = var0.length();
    var0.set(1, 100);
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    var9.clear(0, 0);
    var0.and(var9);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      int var29 = var0.nextClearBit((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);

  }

  public void test101() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test101");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    int var13 = var8.cardinality();
    var8.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 1);

  }

  public void test102() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test102");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.clear(1, 100);
    int var10 = var0.nextSetBit(1);
    int var12 = var0.nextClearBit(1);
    int var13 = var0.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 1);

  }

  public void test103() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test103");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    int var35 = var32.length();
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    var36.set(100, true);
    boolean var42 = var32.intersects(var36);
    boolean var43 = var31.intersects(var36);
    boolean var44 = var0.equals((java.lang.Object)var31);
    var0.set(128, false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == true);

  }

  public void test104() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test104");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    int var35 = var32.length();
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    var36.set(100, true);
    boolean var42 = var32.intersects(var36);
    boolean var43 = var31.intersects(var36);
    boolean var44 = var0.equals((java.lang.Object)var31);
    int var46 = var0.nextSetBit(128);
    BitSet var47 = new BitSet();
    boolean var49 = var47.get(0);
    int var50 = var47.length();
    int var51 = var47.size();
    boolean var52 = var0.equals((java.lang.Object)var51);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);

  }

  public void test105() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test105");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    var20.and(var28);
    var28.flip(1);
    boolean var34 = var28.get(100);
    int var35 = var28.size();
    int var36 = var28.cardinality();
    var6.xor(var28);
    java.lang.String var38 = var28.toString();
    int var40 = var28.nextClearBit(10);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    BitSet var44 = new BitSet();
    var41.xor(var44);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    BitSet var49 = new BitSet();
    var46.xor(var49);
    var41.and(var49);
    int var52 = var41.cardinality();
    var41.clear();
    java.lang.String var54 = var41.toString();
    java.lang.String var55 = var41.toString();
    BitSet var56 = new BitSet();
    boolean var58 = var56.get(0);
    int var59 = var56.length();
    BitSet var60 = new BitSet();
    boolean var62 = var60.get(0);
    var60.set(100, true);
    boolean var66 = var56.intersects(var60);
    boolean var68 = var56.equals((java.lang.Object)(-1L));
    var56.flip(0);
    BitSet var73 = var56.get(64, 100);
    var41.or(var56);
    BitSet var75 = new BitSet();
    boolean var77 = var75.get(0);
    int var78 = var75.length();
    BitSet var79 = new BitSet();
    boolean var81 = var79.get(0);
    var79.set(100, true);
    boolean var85 = var75.intersects(var79);
    int var86 = var79.cardinality();
    var41.xor(var79);
    var28.or(var79);
    boolean var90 = var28.get(65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var38 + "' != '" + "{1}"+ "'", var38.equals("{1}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var54 + "' != '" + "{}"+ "'", var54.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var55 + "' != '" + "{}"+ "'", var55.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var73);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var77 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var78 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var81 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var86 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var90 == false);

  }

  public void test106() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test106");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.set(1, 100);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    boolean var33 = var14.get(54);
    var8.and(var14);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var8.set((-1), 128);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);

  }

  public void test107() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test107");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    int var24 = var11.nextClearBit(65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == 65);

  }

  public void test108() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test108");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    int var18 = var15.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    var19.set(100, true);
    boolean var25 = var15.intersects(var19);
    int var26 = var15.size();
    java.lang.Object var27 = var15.clone();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    var28.set(0, true);
    int var38 = var28.nextSetBit(64);
    BitSet var40 = new BitSet(10);
    var28.or(var40);
    boolean var42 = var15.intersects(var28);
    BitSet var43 = new BitSet();
    boolean var45 = var43.get(0);
    BitSet var46 = new BitSet();
    var43.xor(var46);
    BitSet var48 = new BitSet();
    boolean var50 = var48.get(0);
    BitSet var51 = new BitSet();
    var48.xor(var51);
    var43.and(var51);
    boolean var54 = var43.isEmpty();
    int var55 = var43.size();
    BitSet var56 = new BitSet();
    boolean var58 = var56.get(0);
    int var59 = var56.length();
    BitSet var60 = new BitSet();
    boolean var62 = var60.get(0);
    var60.set(100, true);
    boolean var66 = var56.intersects(var60);
    boolean var67 = var56.isEmpty();
    var56.set(10, 100);
    var43.xor(var56);
    int var73 = var43.nextClearBit(10);
    boolean var74 = var28.intersects(var43);
    BitSet var75 = new BitSet();
    boolean var77 = var75.get(0);
    BitSet var78 = new BitSet();
    var75.xor(var78);
    BitSet var80 = new BitSet();
    boolean var82 = var80.get(0);
    BitSet var83 = new BitSet();
    var80.xor(var83);
    var75.and(var83);
    var75.set(10);
    boolean var88 = var43.equals((java.lang.Object)var75);
    var75.set(1, 64, false);
    var0.or(var75);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var27);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var74 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var77 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var82 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var88 == false);

  }

  public void test109() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test109");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.set(64, false);
    BitSet var17 = new BitSet();
    int var18 = var17.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    int var22 = var19.length();
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    var23.set(100, true);
    boolean var29 = var19.intersects(var23);
    int var30 = var19.size();
    var17.or(var19);
    var17.clear();
    var17.clear();
    var0.andNot(var17);
    boolean var36 = var0.get(2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);

  }

  public void test110() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test110");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var3.clear();
    java.lang.Object var11 = var3.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var11);

  }

  public void test111() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test111");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    int var7 = var3.length();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var3.set(10, 2, false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == 0);

  }

  public void test112() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test112");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    boolean var10 = var3.isEmpty();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    int var14 = var11.length();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    var15.set(100, true);
    boolean var21 = var11.intersects(var15);
    int var22 = var11.size();
    java.lang.Object var23 = var11.clone();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    var24.set(0, true);
    int var34 = var24.nextSetBit(64);
    BitSet var36 = new BitSet(10);
    var24.or(var36);
    boolean var38 = var11.intersects(var24);
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    BitSet var42 = new BitSet();
    var39.xor(var42);
    BitSet var44 = new BitSet();
    boolean var46 = var44.get(0);
    BitSet var47 = new BitSet();
    var44.xor(var47);
    var39.and(var47);
    boolean var50 = var39.isEmpty();
    int var51 = var39.size();
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    int var55 = var52.length();
    BitSet var56 = new BitSet();
    boolean var58 = var56.get(0);
    var56.set(100, true);
    boolean var62 = var52.intersects(var56);
    boolean var63 = var52.isEmpty();
    var52.set(10, 100);
    var39.xor(var52);
    int var69 = var39.nextClearBit(10);
    boolean var70 = var24.intersects(var39);
    BitSet var71 = new BitSet();
    boolean var73 = var71.get(0);
    BitSet var74 = new BitSet();
    var71.xor(var74);
    BitSet var76 = new BitSet();
    boolean var78 = var76.get(0);
    BitSet var79 = new BitSet();
    var76.xor(var79);
    var71.and(var79);
    var71.set(10);
    boolean var84 = var39.equals((java.lang.Object)var71);
    boolean var85 = var3.equals((java.lang.Object)var71);
    int var86 = var71.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var23);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var78 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var86 == 1);

  }

  public void test113() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test113");


    BitSet var0 = new BitSet();
    var0.set(65);

  }

  public void test114() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test114");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    BitSet var16 = new BitSet(0);
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    int var26 = var23.length();
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    var27.set(100, true);
    boolean var33 = var23.intersects(var27);
    boolean var35 = var23.equals((java.lang.Object)(-1L));
    var17.or(var23);
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    BitSet var40 = new BitSet();
    var37.xor(var40);
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    BitSet var45 = new BitSet();
    var42.xor(var45);
    var37.and(var45);
    var45.flip(1);
    boolean var51 = var45.get(100);
    int var52 = var45.size();
    int var53 = var45.cardinality();
    var23.xor(var45);
    var23.flip(0, 128);
    var16.xor(var23);
    var0.xor(var23);
    boolean var61 = var0.get(128);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(100, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);

  }

  public void test115() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test115");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var28.get(54);
    var28.set(64, true);
    int var41 = var28.nextSetBit(54);
    int var42 = var28.size();
    boolean var43 = var7.intersects(var28);
    BitSet var44 = new BitSet();
    boolean var46 = var44.get(0);
    int var47 = var44.length();
    BitSet var48 = new BitSet();
    boolean var50 = var48.get(0);
    var48.set(100, true);
    boolean var54 = var44.intersects(var48);
    var44.set(0, 1);
    var28.andNot(var44);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      int var60 = var28.nextSetBit((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);

  }

  public void test116() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test116");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    var0.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);

  }

  public void test117() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test117");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.set(64);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var30 = var26.nextClearBit(0);
    java.lang.Object var31 = var26.clone();
    var3.or(var26);
    var3.clear(2, 101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);

  }

  public void test118() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test118");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.set(0, true);
    int var10 = var0.nextSetBit(64);
    BitSet var12 = new BitSet(10);
    var0.or(var12);
    boolean var15 = var12.get(54);
    int var17 = var12.nextSetBit(10);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var20 = var12.get(2, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == (-1));

  }

  public void test119() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test119");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.set(0, true);
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    BitSet var26 = var9.get(64, 100);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var38 = var26.intersects(var31);
    var0.andNot(var31);
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    BitSet var43 = new BitSet();
    var40.xor(var43);
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    BitSet var48 = new BitSet();
    var45.xor(var48);
    var40.and(var48);
    boolean var51 = var40.isEmpty();
    var40.clear(10, 10);
    int var55 = var40.cardinality();
    java.lang.Object var56 = var40.clone();
    boolean var57 = var0.equals((java.lang.Object)var40);
    boolean var58 = var0.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var56);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);

  }

  public void test120() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test120");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    int var16 = var13.length();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    boolean var23 = var13.intersects(var17);
    int var24 = var13.size();
    java.lang.Object var25 = var13.clone();
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    var26.set(100, true);
    var26.set(0, true);
    int var36 = var26.nextSetBit(64);
    BitSet var38 = new BitSet(10);
    var26.or(var38);
    boolean var40 = var13.intersects(var26);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    BitSet var44 = new BitSet();
    var41.xor(var44);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    BitSet var49 = new BitSet();
    var46.xor(var49);
    var41.and(var49);
    boolean var52 = var41.isEmpty();
    int var53 = var41.size();
    BitSet var54 = new BitSet();
    boolean var56 = var54.get(0);
    int var57 = var54.length();
    BitSet var58 = new BitSet();
    boolean var60 = var58.get(0);
    var58.set(100, true);
    boolean var64 = var54.intersects(var58);
    boolean var65 = var54.isEmpty();
    var54.set(10, 100);
    var41.xor(var54);
    int var71 = var41.nextClearBit(10);
    boolean var72 = var26.intersects(var41);
    BitSet var73 = new BitSet();
    boolean var75 = var73.get(0);
    BitSet var76 = new BitSet();
    var73.xor(var76);
    BitSet var78 = new BitSet();
    boolean var80 = var78.get(0);
    BitSet var81 = new BitSet();
    var78.xor(var81);
    var73.and(var81);
    var73.set(10);
    boolean var86 = var41.equals((java.lang.Object)var73);
    boolean var87 = var8.intersects(var41);
    int var88 = var41.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var25);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var80 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var86 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var87 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var88 == 90);

  }

  public void test121() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test121");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    int var4 = var0.size();
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    BitSet var13 = new BitSet();
    var10.xor(var13);
    var5.and(var13);
    var13.flip(1);
    int var18 = var13.cardinality();
    var0.andNot(var13);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    int var23 = var20.length();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    boolean var30 = var20.intersects(var24);
    int var31 = var20.size();
    java.lang.Object var32 = var20.clone();
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    int var36 = var33.length();
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    var37.set(100, true);
    boolean var43 = var33.intersects(var37);
    boolean var45 = var33.equals((java.lang.Object)(-1L));
    var33.flip(0);
    BitSet var50 = var33.get(64, 100);
    BitSet var51 = new BitSet();
    boolean var53 = var51.get(0);
    var51.set(100, true);
    BitSet var57 = new BitSet();
    boolean var59 = var57.get(0);
    int var60 = var57.length();
    BitSet var61 = new BitSet();
    boolean var63 = var61.get(0);
    var61.set(100, true);
    boolean var67 = var57.intersects(var61);
    boolean var69 = var57.equals((java.lang.Object)(-1L));
    var51.or(var57);
    boolean var71 = var33.intersects(var57);
    int var72 = var57.size();
    BitSet var73 = new BitSet();
    boolean var75 = var73.get(0);
    var73.set(100, true);
    boolean var80 = var73.equals((java.lang.Object)'a');
    boolean var81 = var57.intersects(var73);
    boolean var82 = var20.equals((java.lang.Object)var73);
    boolean var83 = var0.intersects(var73);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var32);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var50);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var80 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var81 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var82 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var83 == false);

  }

  public void test122() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test122");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(64, 100);
    var9.clear();
    var9.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);

  }

  public void test123() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test123");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var18 = var0.isEmpty();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    int var22 = var19.length();
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    var23.set(100, true);
    boolean var29 = var19.intersects(var23);
    int var30 = var19.size();
    var0.xor(var19);
    int var33 = var0.nextSetBit(90);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == (-1));

  }

  public void test124() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test124");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.set(0, true);
    int var23 = var13.nextSetBit(64);
    BitSet var25 = new BitSet(10);
    var13.or(var25);
    boolean var27 = var0.intersects(var13);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    boolean var39 = var28.isEmpty();
    int var40 = var28.size();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    int var44 = var41.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    boolean var51 = var41.intersects(var45);
    boolean var52 = var41.isEmpty();
    var41.set(10, 100);
    var28.xor(var41);
    int var58 = var28.nextClearBit(10);
    boolean var59 = var13.intersects(var28);
    BitSet var60 = new BitSet();
    boolean var62 = var60.get(0);
    BitSet var63 = new BitSet();
    var60.xor(var63);
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    BitSet var68 = new BitSet();
    var65.xor(var68);
    var60.and(var68);
    var60.set(10);
    boolean var73 = var28.equals((java.lang.Object)var60);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var28.set(101, 54);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);

  }

  public void test125() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test125");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    boolean var5 = var3.get(0);
    BitSet var6 = new BitSet();
    var3.xor(var6);
    boolean var9 = var6.equals((java.lang.Object)(-1L));
    BitSet var12 = var6.get(0, 1);
    var12.flip(10, 64);
    int var16 = var12.cardinality();
    var0.xor(var12);
    BitSet var19 = new BitSet(0);
    var0.andNot(var19);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(90, 1, false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 54);

  }

  public void test126() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test126");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.set(1, 100);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    boolean var33 = var14.get(54);
    var8.and(var14);
    var14.set(0, false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);

  }

  public void test127() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test127");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var4 = var0.nextClearBit(0);
    java.lang.Object var5 = var0.clone();
    var0.flip(54);
    BitSet var9 = new BitSet(54);
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    BitSet var13 = new BitSet();
    var10.xor(var13);
    boolean var16 = var13.equals((java.lang.Object)(-1L));
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    int var20 = var17.length();
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    var21.set(100, true);
    boolean var27 = var17.intersects(var21);
    boolean var29 = var17.equals((java.lang.Object)(-1L));
    var17.flip(0);
    int var32 = var17.cardinality();
    boolean var33 = var13.intersects(var17);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    boolean var46 = var38.get(54);
    var38.set(64, true);
    int var51 = var38.nextSetBit(54);
    int var52 = var38.size();
    boolean var53 = var17.intersects(var38);
    var9.andNot(var38);
    var0.or(var9);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(64, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var5);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);

  }

  public void test128() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test128");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    var9.clear();
    java.lang.String var14 = var9.toString();
    var9.clear(100);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var19 = var9.get(10, 0);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));

  }

  public void test129() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test129");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var24.equals((java.lang.Object)(-1L));
    var18.or(var24);
    boolean var38 = var0.intersects(var24);
    int var39 = var24.size();
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    var40.set(100, true);
    boolean var47 = var40.equals((java.lang.Object)'a');
    boolean var48 = var24.intersects(var40);
    var24.set(128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);

  }

  public void test130() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test130");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    int var15 = var0.length();
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    boolean var22 = var19.equals((java.lang.Object)(-1L));
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    int var26 = var23.length();
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    var27.set(100, true);
    boolean var33 = var23.intersects(var27);
    boolean var35 = var23.equals((java.lang.Object)(-1L));
    var23.flip(0);
    int var38 = var23.cardinality();
    boolean var39 = var19.intersects(var23);
    var19.flip(1, 1);
    BitSet var43 = new BitSet();
    boolean var45 = var43.get(0);
    int var46 = var43.length();
    BitSet var47 = new BitSet();
    boolean var49 = var47.get(0);
    var47.set(100, true);
    boolean var53 = var43.intersects(var47);
    boolean var55 = var43.equals((java.lang.Object)(-1L));
    BitSet var58 = var43.get(1, 100);
    var19.or(var43);
    var0.or(var19);
    int var61 = var0.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var58);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == 1);

  }

  public void test131() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test131");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var11 = var0.isEmpty();
    var0.set(10, 100);
    java.lang.Object var15 = var0.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);

  }

  public void test132() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test132");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var8.clear(64, 64);
    boolean var19 = var8.get(54);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var29 = var26.length();
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    var30.set(100, true);
    boolean var36 = var26.intersects(var30);
    boolean var37 = var20.intersects(var30);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    int var41 = var38.length();
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    var42.set(100, true);
    boolean var48 = var38.intersects(var42);
    boolean var50 = var38.equals((java.lang.Object)(-1L));
    var30.xor(var38);
    int var52 = var38.length();
    boolean var53 = var8.equals((java.lang.Object)var52);
    BitSet var54 = new BitSet();
    boolean var56 = var54.get(0);
    BitSet var57 = new BitSet();
    var54.xor(var57);
    boolean var60 = var57.equals((java.lang.Object)(-1L));
    BitSet var61 = new BitSet();
    boolean var63 = var61.get(0);
    int var64 = var61.length();
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    var65.set(100, true);
    boolean var71 = var61.intersects(var65);
    boolean var73 = var61.equals((java.lang.Object)(-1L));
    var61.flip(0);
    int var76 = var61.cardinality();
    boolean var77 = var57.intersects(var61);
    BitSet var78 = new BitSet();
    boolean var80 = var78.get(0);
    int var81 = var78.length();
    BitSet var82 = new BitSet();
    boolean var84 = var82.get(0);
    var82.set(100, true);
    boolean var88 = var78.intersects(var82);
    boolean var90 = var82.get(54);
    var82.set(64, true);
    int var95 = var82.nextSetBit(54);
    int var96 = var82.size();
    boolean var97 = var61.intersects(var82);
    int var98 = var82.length();
    var8.and(var82);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var76 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var77 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var80 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var81 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var88 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var90 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var95 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var96 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var97 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var98 == 101);

  }

  public void test133() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test133");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var4.get(54);
    var4.set(64, true);
    int var17 = var4.nextClearBit(64);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    var18.set(0, true);
    int var28 = var18.nextSetBit(64);
    boolean var29 = var4.equals((java.lang.Object)64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);

  }

  public void test134() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test134");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    boolean var29 = var26.equals((java.lang.Object)(-1L));
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    boolean var42 = var30.equals((java.lang.Object)(-1L));
    var30.flip(0);
    int var45 = var30.cardinality();
    boolean var46 = var26.intersects(var30);
    var0.and(var30);
    java.lang.String var48 = var0.toString();
    int var49 = var0.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var48 + "' != '" + "{}"+ "'", var48.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 64);

  }

  public void test135() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test135");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    var20.and(var28);
    var28.flip(1);
    boolean var34 = var28.get(100);
    int var35 = var28.size();
    int var36 = var28.cardinality();
    var6.xor(var28);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.flip(1);
    int var43 = var38.length();
    int var44 = var38.cardinality();
    boolean var45 = var6.intersects(var38);
    java.lang.String var46 = var6.toString();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var46 + "' != '" + "{1}"+ "'", var46.equals("{1}"));

  }

  public void test136() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test136");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var19 = var0.get(54);
    boolean var21 = var0.get(101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);

  }

  public void test137() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test137");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    BitSet var15 = var0.get(1, 100);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    BitSet var24 = new BitSet();
    var21.xor(var24);
    var16.and(var24);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    boolean var38 = var16.intersects(var27);
    var0.xor(var16);
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    BitSet var43 = new BitSet();
    var40.xor(var43);
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    BitSet var48 = new BitSet();
    var45.xor(var48);
    var40.and(var48);
    var48.flip(1);
    boolean var54 = var48.get(100);
    int var55 = var48.size();
    int var56 = var48.cardinality();
    BitSet var57 = new BitSet();
    boolean var59 = var57.get(0);
    BitSet var60 = new BitSet();
    var57.xor(var60);
    boolean var63 = var60.equals((java.lang.Object)(-1L));
    BitSet var66 = var60.get(0, 1);
    BitSet var67 = new BitSet();
    boolean var69 = var67.get(0);
    int var70 = var67.length();
    BitSet var71 = new BitSet();
    boolean var73 = var71.get(0);
    var71.set(100, true);
    boolean var77 = var67.intersects(var71);
    int var78 = var71.cardinality();
    var66.andNot(var71);
    boolean var80 = var48.intersects(var71);
    var16.and(var48);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var66);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var77 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var78 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var80 == false);

  }

  public void test138() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test138");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);

  }

  public void test139() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test139");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    int var34 = var31.length();
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    var35.set(100, true);
    var35.set(0, true);
    var31.andNot(var35);
    var31.flip(64);
    var31.set(100, false);
    var18.xor(var31);
    boolean var51 = var0.intersects(var31);
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    int var56 = var52.nextClearBit(0);
    var0.or(var52);
    int var58 = var0.length();
    BitSet var60 = new BitSet(0);
    var60.clear(1);
    var0.or(var60);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 1);

  }

  public void test140() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test140");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    int var15 = var0.cardinality();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set((-1), false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);

  }

  public void test141() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test141");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    var0.set(54, true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);

  }

  public void test142() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test142");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(54, 1, true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);

  }

  public void test143() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test143");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    int var2 = var0.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == 0);

  }

  public void test144() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test144");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    boolean var14 = var0.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == true);

  }

  public void test145() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test145");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var17 = var0.intersects(var10);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    var10.xor(var18);
    var10.set(55, false);
    boolean var35 = var10.isEmpty();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var38 = var10.get(101, 90);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);

  }

  public void test146() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test146");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    int var15 = var0.cardinality();
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    var20.set(0, true);
    var16.andNot(var20);
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    BitSet var44 = new BitSet();
    var41.xor(var44);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    BitSet var49 = new BitSet();
    var46.xor(var49);
    var41.and(var49);
    var49.flip(1);
    boolean var55 = var49.get(100);
    int var57 = var49.nextSetBit(1);
    var34.xor(var49);
    boolean var59 = var20.intersects(var49);
    var0.or(var20);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var20.clear(101, 64);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);

  }

  public void test147() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test147");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.set(0, true);
    int var23 = var13.nextSetBit(64);
    BitSet var25 = new BitSet(10);
    var13.or(var25);
    boolean var27 = var0.intersects(var13);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    boolean var39 = var28.isEmpty();
    int var40 = var28.size();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    int var44 = var41.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    boolean var51 = var41.intersects(var45);
    boolean var52 = var41.isEmpty();
    var41.set(10, 100);
    var28.xor(var41);
    int var58 = var28.nextClearBit(10);
    boolean var59 = var13.intersects(var28);
    java.lang.Object var60 = var13.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var60);

  }

  public void test148() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test148");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    var0.flip(54, 64);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    var23.and(var31);
    boolean var34 = var23.isEmpty();
    int var35 = var23.size();
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    int var39 = var36.length();
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    var40.set(100, true);
    boolean var46 = var36.intersects(var40);
    boolean var47 = var36.isEmpty();
    var36.set(10, 100);
    var23.xor(var36);
    int var53 = var23.nextClearBit(10);
    boolean var54 = var0.equals((java.lang.Object)var53);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);

  }

  public void test149() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test149");


    BitSet var1 = new BitSet(10);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var4 = var1.get((-1), 10);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }

  }

  public void test150() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test150");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    BitSet var15 = var0.get(1, 100);
    boolean var17 = var0.get(54);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(128, 55);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);

  }

  public void test151() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test151");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    boolean var14 = var8.get(100);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    var15.flip(1);
    int var20 = var15.length();
    var15.set(1, 100);
    var8.or(var15);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var8.flip((-1), 10);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 2);

  }

  public void test152() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test152");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    java.lang.Object var18 = new java.lang.Object();
    boolean var19 = var0.equals(var18);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);

  }

  public void test153() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test153");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var7.clear(2);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    BitSet var29 = new BitSet();
    var26.xor(var29);
    boolean var32 = var29.equals((java.lang.Object)(-1L));
    BitSet var35 = var29.get(0, 1);
    var35.flip(10, 64);
    var35.clear();
    java.lang.String var40 = var35.toString();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    BitSet var44 = new BitSet();
    var41.xor(var44);
    boolean var47 = var44.equals((java.lang.Object)(-1L));
    BitSet var50 = var44.get(0, 1);
    var35.xor(var44);
    BitSet var54 = var44.get(0, 65);
    boolean var55 = var7.intersects(var54);
    java.lang.String var56 = var54.toString();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var54.set(100, 55, false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var35);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var40 + "' != '" + "{}"+ "'", var40.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var50);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var56 + "' != '" + "{}"+ "'", var56.equals("{}"));

  }

  public void test154() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test154");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    var15.set(100, true);
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    int var24 = var21.length();
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    var25.set(100, true);
    boolean var31 = var21.intersects(var25);
    boolean var33 = var21.equals((java.lang.Object)(-1L));
    var15.or(var21);
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    BitSet var38 = new BitSet();
    var35.xor(var38);
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    BitSet var43 = new BitSet();
    var40.xor(var43);
    var35.and(var43);
    var43.flip(1);
    boolean var49 = var43.get(100);
    int var50 = var43.size();
    int var51 = var43.cardinality();
    var21.xor(var43);
    java.lang.String var53 = var43.toString();
    boolean var54 = var0.equals((java.lang.Object)var43);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(55, 54);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var53 + "' != '" + "{1}"+ "'", var53.equals("{1}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);

  }

  public void test155() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test155");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var12 = var8.nextSetBit(1);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var8.set(90, (-1), true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == (-1));

  }

  public void test156() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test156");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    int var16 = var13.length();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    var17.set(0, true);
    var13.andNot(var17);
    var13.flip(64);
    var13.set(100, false);
    var0.xor(var13);
    boolean var34 = var0.equals((java.lang.Object)'a');
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);

  }

  public void test157() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test157");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var4.cardinality();
    boolean var13 = var4.equals((java.lang.Object)1.0d);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    var32.set(100, true);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    int var41 = var38.length();
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    var42.set(100, true);
    boolean var48 = var38.intersects(var42);
    boolean var50 = var38.equals((java.lang.Object)(-1L));
    var32.or(var38);
    boolean var52 = var14.intersects(var38);
    int var53 = var38.size();
    var4.xor(var38);
    int var56 = var38.nextSetBit(2);
    int var57 = var38.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == 0);

  }

  public void test158() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test158");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var17 = var0.intersects(var10);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    var10.xor(var18);
    java.lang.String var32 = var10.toString();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var32 + "' != '" + "{100}"+ "'", var32.equals("{100}"));

  }

  public void test159() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test159");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    boolean var14 = var8.get(100);
    int var15 = var8.size();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var8.set(64, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 64);

  }

  public void test160() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test160");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var8.clear(64, 64);
    boolean var19 = var8.get(54);
    int var21 = var8.nextClearBit(64);
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    BitSet var25 = new BitSet();
    var22.xor(var25);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    var22.and(var30);
    var22.set(100, false);
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    BitSet var39 = new BitSet();
    var36.xor(var39);
    boolean var42 = var39.equals((java.lang.Object)(-1L));
    var22.andNot(var39);
    BitSet var44 = new BitSet();
    boolean var46 = var44.get(0);
    BitSet var47 = new BitSet();
    boolean var49 = var47.get(0);
    BitSet var50 = new BitSet();
    var47.xor(var50);
    boolean var53 = var50.equals((java.lang.Object)(-1L));
    BitSet var56 = var50.get(0, 1);
    var56.flip(10, 64);
    int var60 = var56.cardinality();
    var44.xor(var56);
    var22.xor(var56);
    var8.xor(var56);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var56);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == 54);

  }

  public void test161() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test161");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var24.equals((java.lang.Object)(-1L));
    var18.or(var24);
    boolean var38 = var0.intersects(var24);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);

  }

  public void test162() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test162");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var0.set(100, false);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    BitSet var17 = new BitSet();
    var14.xor(var17);
    boolean var20 = var17.equals((java.lang.Object)(-1L));
    var0.andNot(var17);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var17.flip(100, 64);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);

  }

  public void test163() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test163");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    int var12 = var0.size();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    int var16 = var13.length();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    boolean var23 = var13.intersects(var17);
    boolean var24 = var13.isEmpty();
    var13.set(10, 100);
    var0.xor(var13);
    int var30 = var0.nextClearBit(10);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(55, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 100);

  }

  public void test164() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test164");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    boolean var14 = var0.get(64);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    boolean var21 = var18.equals((java.lang.Object)(-1L));
    BitSet var24 = var18.get(0, 1);
    var24.flip(10, 64);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    var36.flip(1);
    int var41 = var36.cardinality();
    var24.xor(var36);
    var24.clear(101);
    var0.and(var24);
    int var46 = var0.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == 0);

  }

  public void test165() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test165");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var8.clear(64, 64);
    boolean var19 = var8.equals((java.lang.Object)(short)100);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    int var23 = var20.length();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    boolean var30 = var20.intersects(var24);
    boolean var32 = var20.equals((java.lang.Object)(-1L));
    var20.flip(0);
    int var35 = var20.length();
    int var36 = var20.cardinality();
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    BitSet var40 = new BitSet();
    var37.xor(var40);
    boolean var43 = var40.equals((java.lang.Object)(-1L));
    BitSet var46 = var40.get(0, 1);
    var40.clear();
    var20.andNot(var40);
    int var49 = var40.cardinality();
    boolean var50 = var8.equals((java.lang.Object)var40);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var46);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);

  }

  public void test166() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test166");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    boolean var10 = var3.isEmpty();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    int var14 = var11.length();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    var15.set(100, true);
    boolean var21 = var11.intersects(var15);
    int var22 = var11.size();
    java.lang.Object var23 = var11.clone();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    var24.set(0, true);
    int var34 = var24.nextSetBit(64);
    BitSet var36 = new BitSet(10);
    var24.or(var36);
    boolean var38 = var11.intersects(var24);
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    BitSet var42 = new BitSet();
    var39.xor(var42);
    BitSet var44 = new BitSet();
    boolean var46 = var44.get(0);
    BitSet var47 = new BitSet();
    var44.xor(var47);
    var39.and(var47);
    boolean var50 = var39.isEmpty();
    int var51 = var39.size();
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    int var55 = var52.length();
    BitSet var56 = new BitSet();
    boolean var58 = var56.get(0);
    var56.set(100, true);
    boolean var62 = var52.intersects(var56);
    boolean var63 = var52.isEmpty();
    var52.set(10, 100);
    var39.xor(var52);
    int var69 = var39.nextClearBit(10);
    boolean var70 = var24.intersects(var39);
    BitSet var71 = new BitSet();
    boolean var73 = var71.get(0);
    BitSet var74 = new BitSet();
    var71.xor(var74);
    BitSet var76 = new BitSet();
    boolean var78 = var76.get(0);
    BitSet var79 = new BitSet();
    var76.xor(var79);
    var71.and(var79);
    var71.set(10);
    boolean var84 = var39.equals((java.lang.Object)var71);
    boolean var85 = var3.equals((java.lang.Object)var71);
    boolean var86 = var3.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var23);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var78 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var86 == true);

  }

  public void test167() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test167");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    int var16 = var13.length();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    boolean var23 = var13.intersects(var17);
    boolean var25 = var13.equals((java.lang.Object)(-1L));
    var13.flip(0);
    BitSet var30 = var13.get(64, 100);
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    int var40 = var37.length();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    var41.set(100, true);
    boolean var47 = var37.intersects(var41);
    boolean var49 = var37.equals((java.lang.Object)(-1L));
    var31.or(var37);
    boolean var51 = var13.intersects(var37);
    int var52 = var37.size();
    BitSet var53 = new BitSet();
    boolean var55 = var53.get(0);
    var53.set(100, true);
    boolean var60 = var53.equals((java.lang.Object)'a');
    boolean var61 = var37.intersects(var53);
    boolean var62 = var0.equals((java.lang.Object)var53);
    BitSet var63 = new BitSet();
    boolean var65 = var63.get(0);
    int var66 = var63.length();
    var63.clear(1);
    BitSet var69 = new BitSet();
    boolean var71 = var69.get(0);
    BitSet var72 = new BitSet();
    var69.xor(var72);
    boolean var75 = var72.equals((java.lang.Object)(-1L));
    BitSet var78 = var72.get(0, 1);
    BitSet var79 = new BitSet();
    boolean var81 = var79.get(0);
    int var82 = var79.length();
    BitSet var83 = new BitSet();
    boolean var85 = var83.get(0);
    var83.set(100, true);
    boolean var89 = var79.intersects(var83);
    int var90 = var83.cardinality();
    var78.andNot(var83);
    var63.xor(var78);
    var0.or(var78);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var30);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var78);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var81 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var82 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var89 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var90 == 1);

  }

  public void test168() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test168");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.set(1, 100);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    boolean var33 = var14.get(54);
    var8.and(var14);
    int var35 = var14.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 1);

  }

  public void test169() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test169");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var17 = var0.intersects(var10);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    var10.xor(var18);
    boolean var32 = var18.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == true);

  }

  public void test170() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test170");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.set(64);
    boolean var27 = var3.get(128);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    int var31 = var28.length();
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    var32.set(100, true);
    boolean var38 = var28.intersects(var32);
    boolean var40 = var28.equals((java.lang.Object)(-1L));
    var28.flip(0);
    BitSet var45 = var28.get(64, 100);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    int var49 = var46.length();
    BitSet var50 = new BitSet();
    boolean var52 = var50.get(0);
    var50.set(100, true);
    boolean var56 = var46.intersects(var50);
    boolean var58 = var46.equals((java.lang.Object)(-1L));
    BitSet var59 = new BitSet();
    boolean var61 = var59.get(0);
    int var62 = var59.length();
    BitSet var63 = new BitSet();
    boolean var65 = var63.get(0);
    var63.set(100, true);
    var63.set(0, true);
    var59.andNot(var63);
    var59.flip(64);
    var59.set(100, false);
    var46.xor(var59);
    boolean var79 = var28.intersects(var59);
    var3.or(var28);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var28.set(90, 0, false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var45);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var79 == false);

  }

  public void test171() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test171");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    var35.flip(1);
    boolean var41 = var35.get(100);
    int var43 = var35.nextSetBit(1);
    var20.xor(var35);
    var0.andNot(var35);
    int var46 = var0.length();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == 65);

  }

  public void test172() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test172");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    boolean var29 = var26.equals((java.lang.Object)(-1L));
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    boolean var42 = var30.equals((java.lang.Object)(-1L));
    var30.flip(0);
    int var45 = var30.cardinality();
    boolean var46 = var26.intersects(var30);
    var0.and(var30);
    var0.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);

  }

  public void test173() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test173");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    int var12 = var0.size();
    var0.set(0, true);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(90, 0, true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 64);

  }

  public void test174() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test174");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.flip(1, 1);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var39 = var27.equals((java.lang.Object)(-1L));
    BitSet var42 = var27.get(1, 100);
    var3.or(var27);
    int var45 = var3.nextSetBit(1);
    java.lang.String var46 = var3.toString();
    int var47 = var3.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var42);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var46 + "' != '" + "{}"+ "'", var46.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == 64);

  }

  public void test175() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test175");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var13.clear(1);
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    BitSet var20 = new BitSet();
    var17.xor(var20);
    boolean var23 = var20.equals((java.lang.Object)(-1L));
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var24.equals((java.lang.Object)(-1L));
    var24.flip(0);
    int var39 = var24.cardinality();
    boolean var40 = var20.intersects(var24);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    int var44 = var41.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    boolean var51 = var41.intersects(var45);
    boolean var53 = var45.get(54);
    var45.set(64, true);
    int var58 = var45.nextSetBit(54);
    int var59 = var45.size();
    boolean var60 = var24.intersects(var45);
    var13.xor(var45);
    BitSet var62 = new BitSet();
    boolean var64 = var62.get(0);
    BitSet var65 = new BitSet();
    var62.xor(var65);
    boolean var68 = var65.equals((java.lang.Object)(-1L));
    BitSet var71 = var65.get(0, 1);
    var71.flip(64, 100);
    var45.andNot(var71);
    var45.clear(2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var71);

  }

  public void test176() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test176");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var3.clear();
    BitSet var13 = var3.get(65, 65);
    var3.set(1, true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var13);

  }

  public void test177() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test177");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.set(64, false);
    BitSet var17 = new BitSet();
    int var18 = var17.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    int var22 = var19.length();
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    var23.set(100, true);
    boolean var29 = var19.intersects(var23);
    int var30 = var19.size();
    var17.or(var19);
    var17.clear();
    var17.clear();
    var0.andNot(var17);
    var0.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 64);

  }

  public void test178() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test178");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    boolean var14 = var0.get(64);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    boolean var21 = var18.equals((java.lang.Object)(-1L));
    BitSet var24 = var18.get(0, 1);
    var24.flip(10, 64);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    var36.flip(1);
    int var41 = var36.cardinality();
    var24.xor(var36);
    var24.clear(101);
    var0.and(var24);
    int var47 = var0.nextClearBit(0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == 0);

  }

  public void test179() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test179");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    int var13 = var2.size();
    var0.or(var2);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    int var18 = var15.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    var19.set(100, true);
    boolean var25 = var15.intersects(var19);
    boolean var27 = var15.equals((java.lang.Object)(-1L));
    var15.flip(0);
    var0.or(var15);
    boolean var31 = var15.isEmpty();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var34 = var15.get(64, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);

  }

  public void test180() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test180");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.set(1, 100);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    boolean var33 = var14.get(54);
    var8.and(var14);
    BitSet var35 = new BitSet();
    int var36 = var35.length();
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    int var40 = var37.length();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    var41.set(100, true);
    boolean var47 = var37.intersects(var41);
    boolean var49 = var37.equals((java.lang.Object)(-1L));
    var37.flip(0);
    BitSet var54 = var37.get(64, 100);
    BitSet var55 = new BitSet();
    boolean var57 = var55.get(0);
    int var58 = var55.length();
    BitSet var59 = new BitSet();
    boolean var61 = var59.get(0);
    var59.set(100, true);
    boolean var65 = var55.intersects(var59);
    boolean var66 = var54.intersects(var59);
    var35.and(var54);
    java.lang.String var68 = var35.toString();
    boolean var69 = var14.equals((java.lang.Object)var68);
    BitSet var72 = var14.get(0, 54);
    boolean var74 = var72.get(1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var68 + "' != '" + "{}"+ "'", var68.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var72);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var74 == false);

  }

  public void test181() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test181");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    int var15 = var0.cardinality();
    int var16 = var0.length();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(65, 2, true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 0);

  }

  public void test182() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test182");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    int var5 = var0.length();
    var0.set(1, 100);
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    var9.clear(0, 0);
    var0.and(var9);
    var9.set(54, false);
    int var32 = var9.nextSetBit(55);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == (-1));

  }

  public void test183() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test183");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    boolean var5 = var3.get(0);
    BitSet var6 = new BitSet();
    var3.xor(var6);
    boolean var9 = var6.equals((java.lang.Object)(-1L));
    BitSet var12 = var6.get(0, 1);
    var12.flip(10, 64);
    int var16 = var12.cardinality();
    var0.xor(var12);
    var0.set(100, true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 54);

  }

  public void test184() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test184");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    var9.clear();
    var9.clear(90, 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);

  }

  public void test185() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test185");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var0.flip(54);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var15 = var0.get((-1), 2);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);

  }

  public void test186() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test186");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var19 = var0.get(54);
    var0.flip(1);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(100, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);

  }

  public void test187() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test187");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var8.clear(64, 64);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    int var31 = var18.cardinality();
    java.lang.String var32 = var18.toString();
    var8.or(var18);
    int var34 = var18.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var32 + "' != '" + "{}"+ "'", var32.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 0);

  }

  public void test188() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test188");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    int var35 = var32.length();
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    var36.set(100, true);
    boolean var42 = var32.intersects(var36);
    boolean var43 = var31.intersects(var36);
    boolean var44 = var0.equals((java.lang.Object)var31);
    var0.flip(54);
    boolean var47 = var0.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);

  }

  public void test189() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test189");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var3.clear();
    var3.clear(1);
    var3.flip(65, 128);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var3.set(64, 2);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);

  }

  public void test190() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test190");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    var20.and(var28);
    var28.flip(1);
    boolean var34 = var28.get(100);
    int var35 = var28.size();
    int var36 = var28.cardinality();
    var6.xor(var28);
    var28.set(64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 1);

  }

  public void test191() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test191");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.set(64);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var30 = var26.nextClearBit(0);
    java.lang.Object var31 = var26.clone();
    var3.or(var26);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    int var36 = var33.length();
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    var37.set(100, true);
    boolean var43 = var33.intersects(var37);
    int var44 = var33.size();
    boolean var45 = var26.intersects(var33);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var26.clear((-1), 128);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);

  }

  public void test192() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test192");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.flip(1, 1);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var39 = var27.equals((java.lang.Object)(-1L));
    BitSet var42 = var27.get(1, 100);
    var3.or(var27);
    int var44 = var27.length();
    boolean var46 = var27.get(100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var42);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);

  }

  public void test193() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test193");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    int var13 = var2.size();
    var0.or(var2);
    var0.clear();
    var0.clear();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var19 = var0.get(101, 90);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 64);

  }

  public void test194() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test194");


    BitSet var1 = new BitSet(65);

  }

  public void test195() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test195");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    var35.flip(1);
    boolean var41 = var35.get(100);
    int var43 = var35.nextSetBit(1);
    var20.xor(var35);
    var0.andNot(var35);
    java.lang.String var46 = var0.toString();
    BitSet var49 = var0.get(2, 101);
    boolean var51 = var49.get(101);
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    int var55 = var52.length();
    BitSet var56 = new BitSet();
    boolean var58 = var56.get(0);
    var56.set(100, true);
    boolean var62 = var52.intersects(var56);
    boolean var64 = var52.equals((java.lang.Object)(-1L));
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    int var68 = var65.length();
    BitSet var69 = new BitSet();
    boolean var71 = var69.get(0);
    var69.set(100, true);
    var69.set(0, true);
    var65.andNot(var69);
    var65.flip(64);
    var65.set(100, false);
    var52.xor(var65);
    var52.clear(101);
    var49.andNot(var52);
    var52.clear(64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var46 + "' != '" + "{64}"+ "'", var46.equals("{64}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var49);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);

  }

  public void test196() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test196");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.set(1, 100);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    boolean var33 = var14.get(54);
    var8.and(var14);
    BitSet var35 = new BitSet();
    int var36 = var35.length();
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    int var40 = var37.length();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    var41.set(100, true);
    boolean var47 = var37.intersects(var41);
    boolean var49 = var37.equals((java.lang.Object)(-1L));
    var37.flip(0);
    BitSet var54 = var37.get(64, 100);
    BitSet var55 = new BitSet();
    boolean var57 = var55.get(0);
    int var58 = var55.length();
    BitSet var59 = new BitSet();
    boolean var61 = var59.get(0);
    var59.set(100, true);
    boolean var65 = var55.intersects(var59);
    boolean var66 = var54.intersects(var59);
    var35.and(var54);
    java.lang.String var68 = var35.toString();
    boolean var69 = var14.equals((java.lang.Object)var68);
    var14.flip(128);
    var14.set(128, true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var68 + "' != '" + "{}"+ "'", var68.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == false);

  }

  public void test197() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test197");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(10, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);

  }

  public void test198() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test198");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    boolean var14 = var2.equals((java.lang.Object)(-1L));
    var2.flip(0);
    BitSet var19 = var2.get(64, 100);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    int var23 = var20.length();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    boolean var30 = var20.intersects(var24);
    boolean var31 = var19.intersects(var24);
    var0.and(var19);
    java.lang.String var33 = var0.toString();
    var0.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var19);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var33 + "' != '" + "{}"+ "'", var33.equals("{}"));

  }

  public void test199() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test199");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    var0.flip(54, 64);
    int var24 = var0.nextSetBit(65);
    var0.set(10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == 100);

  }

  public void test200() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test200");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    int var15 = var0.cardinality();
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    var20.set(0, true);
    var16.andNot(var20);
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    BitSet var44 = new BitSet();
    var41.xor(var44);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    BitSet var49 = new BitSet();
    var46.xor(var49);
    var41.and(var49);
    var49.flip(1);
    boolean var55 = var49.get(100);
    int var57 = var49.nextSetBit(1);
    var34.xor(var49);
    boolean var59 = var20.intersects(var49);
    var0.or(var20);
    BitSet var61 = new BitSet();
    boolean var63 = var61.get(0);
    BitSet var64 = new BitSet();
    var61.xor(var64);
    BitSet var66 = new BitSet();
    boolean var68 = var66.get(0);
    BitSet var69 = new BitSet();
    var66.xor(var69);
    var61.and(var69);
    boolean var72 = var61.isEmpty();
    var61.clear(10, 10);
    var61.clear(64);
    var0.xor(var61);
    int var79 = var61.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var79 == 0);

  }

  public void test201() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test201");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.set(0, true);
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    BitSet var26 = var9.get(64, 100);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var38 = var26.intersects(var31);
    var0.andNot(var31);
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    BitSet var43 = new BitSet();
    var40.xor(var43);
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    BitSet var48 = new BitSet();
    var45.xor(var48);
    var40.and(var48);
    boolean var51 = var40.isEmpty();
    var40.clear(10, 10);
    int var55 = var40.cardinality();
    java.lang.Object var56 = var40.clone();
    boolean var57 = var0.equals((java.lang.Object)var40);
    int var58 = var40.size();
    int var59 = var40.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var56);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == 0);

  }

  public void test202() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test202");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    int var28 = var9.length();
    int var30 = var9.nextSetBit(10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 10);

  }

  public void test203() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test203");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var19 = var0.get(54);
    boolean var21 = var0.get(0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == true);

  }

  public void test204() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test204");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.flip(1, 1);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var39 = var27.equals((java.lang.Object)(-1L));
    BitSet var42 = var27.get(1, 100);
    var3.or(var27);
    int var44 = var27.length();
    var27.clear(1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var42);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);

  }

  public void test205() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test205");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    boolean var14 = var0.get(64);
    boolean var16 = var0.get(64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);

  }

  public void test206() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test206");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.clear(1, 100);
    int var9 = var0.cardinality();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    int var13 = var10.length();
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    var14.set(100, true);
    boolean var20 = var10.intersects(var14);
    var10.set(0, 1);
    var0.xor(var10);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(101, 2, true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);

  }

  public void test207() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test207");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    int var28 = var9.length();
    int var29 = var9.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 55);

  }

  public void test208() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test208");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    int var15 = var0.cardinality();
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    var20.set(0, true);
    var16.andNot(var20);
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    BitSet var44 = new BitSet();
    var41.xor(var44);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    BitSet var49 = new BitSet();
    var46.xor(var49);
    var41.and(var49);
    var49.flip(1);
    boolean var55 = var49.get(100);
    int var57 = var49.nextSetBit(1);
    var34.xor(var49);
    boolean var59 = var20.intersects(var49);
    var0.or(var20);
    BitSet var61 = new BitSet();
    boolean var63 = var61.get(0);
    BitSet var64 = new BitSet();
    var61.xor(var64);
    BitSet var66 = new BitSet();
    boolean var68 = var66.get(0);
    BitSet var69 = new BitSet();
    var66.xor(var69);
    var61.and(var69);
    boolean var72 = var61.isEmpty();
    var61.clear(10, 10);
    var61.clear(64);
    var0.xor(var61);
    BitSet var79 = new BitSet();
    boolean var81 = var79.get(0);
    int var82 = var79.length();
    BitSet var83 = new BitSet();
    boolean var85 = var83.get(0);
    var83.set(100, true);
    boolean var89 = var79.intersects(var83);
    boolean var90 = var79.isEmpty();
    var61.andNot(var79);
    var61.set(65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var81 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var82 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var89 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var90 == true);

  }

  public void test209() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test209");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    int var5 = var0.length();
    var0.set(1, 100);
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    var9.clear(0, 0);
    var0.and(var9);
    var9.flip(64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);

  }

  public void test210() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test210");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    var20.and(var28);
    var28.flip(1);
    boolean var34 = var28.get(100);
    int var35 = var28.size();
    int var36 = var28.cardinality();
    var6.xor(var28);
    java.lang.String var38 = var28.toString();
    int var40 = var28.nextClearBit(10);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    BitSet var44 = new BitSet();
    var41.xor(var44);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    BitSet var49 = new BitSet();
    var46.xor(var49);
    var41.and(var49);
    int var52 = var41.cardinality();
    var41.clear();
    java.lang.String var54 = var41.toString();
    java.lang.String var55 = var41.toString();
    BitSet var56 = new BitSet();
    boolean var58 = var56.get(0);
    int var59 = var56.length();
    BitSet var60 = new BitSet();
    boolean var62 = var60.get(0);
    var60.set(100, true);
    boolean var66 = var56.intersects(var60);
    boolean var68 = var56.equals((java.lang.Object)(-1L));
    var56.flip(0);
    BitSet var73 = var56.get(64, 100);
    var41.or(var56);
    BitSet var75 = new BitSet();
    boolean var77 = var75.get(0);
    int var78 = var75.length();
    BitSet var79 = new BitSet();
    boolean var81 = var79.get(0);
    var79.set(100, true);
    boolean var85 = var75.intersects(var79);
    int var86 = var79.cardinality();
    var41.xor(var79);
    var28.or(var79);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var91 = var28.get((-1), 101);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var38 + "' != '" + "{1}"+ "'", var38.equals("{1}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var54 + "' != '" + "{}"+ "'", var54.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var55 + "' != '" + "{}"+ "'", var55.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var73);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var77 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var78 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var81 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var86 == 1);

  }

  public void test211() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test211");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var7.set(54, true);
    int var27 = var7.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    int var31 = var28.length();
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    var32.set(100, true);
    boolean var38 = var28.intersects(var32);
    boolean var40 = var28.equals((java.lang.Object)(-1L));
    var28.flip(0);
    BitSet var45 = var28.get(64, 100);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    int var49 = var46.length();
    BitSet var50 = new BitSet();
    boolean var52 = var50.get(0);
    var50.set(100, true);
    boolean var56 = var46.intersects(var50);
    boolean var57 = var45.intersects(var50);
    var45.clear(64, 64);
    boolean var61 = var7.intersects(var45);
    BitSet var62 = new BitSet();
    boolean var64 = var62.get(0);
    int var65 = var62.length();
    BitSet var66 = new BitSet();
    boolean var68 = var66.get(0);
    var66.set(100, true);
    boolean var72 = var62.intersects(var66);
    boolean var74 = var62.equals((java.lang.Object)(-1L));
    int var75 = var62.cardinality();
    boolean var76 = var62.isEmpty();
    int var77 = var62.cardinality();
    boolean var78 = var7.intersects(var62);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var7.flip(10, 2);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 55);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var45);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var74 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var76 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var77 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var78 == false);

  }

  public void test212() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test212");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    var0.set(65, false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);

  }

  public void test213() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test213");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    var35.flip(1);
    boolean var41 = var35.get(100);
    int var43 = var35.nextSetBit(1);
    var20.xor(var35);
    var0.andNot(var35);
    java.lang.String var46 = var0.toString();
    BitSet var49 = var0.get(2, 101);
    BitSet var50 = new BitSet();
    boolean var52 = var50.get(0);
    int var53 = var50.length();
    BitSet var54 = new BitSet();
    boolean var56 = var54.get(0);
    var54.set(100, true);
    boolean var60 = var50.intersects(var54);
    boolean var62 = var50.equals((java.lang.Object)(-1L));
    int var63 = var50.cardinality();
    java.lang.String var64 = var50.toString();
    int var65 = var50.cardinality();
    boolean var66 = var0.equals((java.lang.Object)var65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var46 + "' != '" + "{64}"+ "'", var46.equals("{64}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var49);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var64 + "' != '" + "{}"+ "'", var64.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);

  }

  public void test214() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test214");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    int var12 = var0.size();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    int var16 = var13.length();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    boolean var23 = var13.intersects(var17);
    boolean var24 = var13.isEmpty();
    var13.set(10, 100);
    var0.xor(var13);
    int var30 = var0.nextClearBit(10);
    int var31 = var0.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == 100);

  }

  public void test215() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test215");


    BitSet var0 = new BitSet();
    BitSet var1 = new BitSet();
    boolean var3 = var1.get(0);
    boolean var4 = var0.equals((java.lang.Object)0);
    var0.flip(10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);

  }

  public void test216() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test216");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    int var13 = var10.length();
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    var14.set(100, true);
    boolean var20 = var10.intersects(var14);
    int var21 = var14.cardinality();
    var9.andNot(var14);
    int var24 = var14.nextSetBit(0);
    java.lang.String var25 = var14.toString();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var25 + "' != '" + "{100}"+ "'", var25.equals("{100}"));

  }

  public void test217() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test217");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    var15.and(var23);
    var0.or(var23);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    boolean var33 = var30.equals((java.lang.Object)(-1L));
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    boolean var46 = var34.equals((java.lang.Object)(-1L));
    var34.flip(0);
    int var49 = var34.cardinality();
    boolean var50 = var30.intersects(var34);
    int var51 = var30.size();
    int var52 = var30.size();
    boolean var53 = var23.equals((java.lang.Object)var30);
    BitSet var54 = new BitSet();
    boolean var56 = var54.get(0);
    BitSet var57 = new BitSet();
    var54.xor(var57);
    boolean var60 = var57.equals((java.lang.Object)(-1L));
    BitSet var61 = new BitSet();
    boolean var63 = var61.get(0);
    int var64 = var61.length();
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    var65.set(100, true);
    boolean var71 = var61.intersects(var65);
    boolean var73 = var61.equals((java.lang.Object)(-1L));
    var61.flip(0);
    int var76 = var61.cardinality();
    boolean var77 = var57.intersects(var61);
    var61.set(54, true);
    var61.clear(65);
    var23.or(var61);
    var61.clear(65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var76 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var77 == false);

  }

  public void test218() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test218");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    int var7 = var3.length();
    java.lang.String var8 = var3.toString();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var3.clear((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var8 + "' != '" + "{}"+ "'", var8.equals("{}"));

  }

  public void test219() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test219");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.set(0, true);
    int var23 = var13.nextSetBit(64);
    BitSet var25 = new BitSet(10);
    var13.or(var25);
    boolean var27 = var0.intersects(var13);
    boolean var28 = var13.isEmpty();
    int var29 = var13.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 128);

  }

  public void test220() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test220");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    boolean var21 = var18.equals((java.lang.Object)(-1L));
    BitSet var24 = var18.get(0, 1);
    var24.flip(64, 100);
    var24.flip(0);
    boolean var30 = var0.intersects(var24);
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    var31.set(0, true);
    var31.set(0, true);
    var24.andNot(var31);
    var24.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);

  }

  public void test221() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test221");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    int var12 = var0.size();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    int var16 = var13.length();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    boolean var23 = var13.intersects(var17);
    boolean var24 = var13.isEmpty();
    var13.set(10, 100);
    var0.xor(var13);
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    var29.set(100, true);
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    int var38 = var35.length();
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    var39.set(100, true);
    boolean var45 = var35.intersects(var39);
    boolean var46 = var29.intersects(var39);
    BitSet var47 = new BitSet();
    boolean var49 = var47.get(0);
    int var50 = var47.length();
    BitSet var51 = new BitSet();
    boolean var53 = var51.get(0);
    var51.set(100, true);
    boolean var57 = var47.intersects(var51);
    boolean var59 = var47.equals((java.lang.Object)(-1L));
    var39.xor(var47);
    boolean var61 = var13.equals((java.lang.Object)var39);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var13.set((-1), 55, true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);

  }

  public void test222() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test222");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    boolean var29 = var26.equals((java.lang.Object)(-1L));
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    boolean var42 = var30.equals((java.lang.Object)(-1L));
    var30.flip(0);
    int var45 = var30.cardinality();
    boolean var46 = var26.intersects(var30);
    var0.and(var30);
    java.lang.String var48 = var0.toString();
    int var50 = var0.nextClearBit(0);
    BitSet var53 = var0.get(1, 101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var48 + "' != '" + "{}"+ "'", var48.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var53);

  }

  public void test223() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test223");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    var0.clear(64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);

  }

  public void test224() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test224");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    var15.and(var23);
    var0.or(var23);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    boolean var33 = var30.equals((java.lang.Object)(-1L));
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    boolean var46 = var34.equals((java.lang.Object)(-1L));
    var34.flip(0);
    int var49 = var34.cardinality();
    boolean var50 = var30.intersects(var34);
    int var51 = var30.size();
    int var52 = var30.size();
    boolean var53 = var23.equals((java.lang.Object)var30);
    int var55 = var23.nextSetBit(100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == (-1));

  }

  public void test225() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test225");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    int var35 = var32.length();
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    var36.set(100, true);
    boolean var42 = var32.intersects(var36);
    boolean var43 = var31.intersects(var36);
    boolean var44 = var0.equals((java.lang.Object)var31);
    BitSet var47 = var0.get(10, 64);
    var0.clear(10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var47);

  }

  public void test226() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test226");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    java.lang.String var12 = var0.toString();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.flip(90, 64);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var12 + "' != '" + "{}"+ "'", var12.equals("{}"));

  }

  public void test227() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test227");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    int var35 = var32.length();
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    var36.set(100, true);
    boolean var42 = var32.intersects(var36);
    boolean var43 = var31.intersects(var36);
    boolean var44 = var0.equals((java.lang.Object)var31);
    int var46 = var0.nextSetBit(128);
    java.lang.Object var47 = var0.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var47);

  }

  public void test228() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test228");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var18 = var0.isEmpty();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    int var22 = var19.length();
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    var23.set(100, true);
    boolean var29 = var19.intersects(var23);
    int var30 = var19.size();
    var0.xor(var19);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    int var35 = var32.length();
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    var36.set(100, true);
    boolean var42 = var32.intersects(var36);
    int var43 = var32.size();
    java.lang.Object var44 = var32.clone();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    var45.set(0, true);
    int var55 = var45.nextSetBit(64);
    BitSet var57 = new BitSet(10);
    var45.or(var57);
    boolean var59 = var32.intersects(var45);
    BitSet var60 = new BitSet();
    boolean var62 = var60.get(0);
    BitSet var63 = new BitSet();
    var60.xor(var63);
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    BitSet var68 = new BitSet();
    var65.xor(var68);
    var60.and(var68);
    boolean var71 = var60.isEmpty();
    int var72 = var60.size();
    BitSet var73 = new BitSet();
    boolean var75 = var73.get(0);
    int var76 = var73.length();
    BitSet var77 = new BitSet();
    boolean var79 = var77.get(0);
    var77.set(100, true);
    boolean var83 = var73.intersects(var77);
    boolean var84 = var73.isEmpty();
    var73.set(10, 100);
    var60.xor(var73);
    int var90 = var60.nextClearBit(10);
    boolean var91 = var45.intersects(var60);
    var60.flip(64, 100);
    boolean var95 = var0.equals((java.lang.Object)64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var44);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var76 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var79 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var83 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var90 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var91 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var95 == false);

  }

  public void test229() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test229");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.clear(1, 100);
    int var10 = var0.nextSetBit(1);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    int var14 = var11.length();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    var15.set(100, true);
    boolean var21 = var11.intersects(var15);
    var15.set(100);
    boolean var24 = var0.intersects(var15);
    int var25 = var15.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == 101);

  }

  public void test230() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test230");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var3.clear();
    var3.clear(1);
    var3.flip(65, 128);
    var3.flip(90);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    int var29 = var18.size();
    var18.clear(64);
    int var32 = var18.length();
    var3.xor(var18);
    var3.set(0, false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == 0);

  }

  public void test231() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test231");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    var9.clear();
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    BitSet var32 = new BitSet();
    var29.xor(var32);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    BitSet var37 = new BitSet();
    var34.xor(var37);
    var29.and(var37);
    var37.flip(1);
    BitSet var42 = new BitSet();
    var37.or(var42);
    var37.clear(64, 64);
    boolean var47 = var9.intersects(var37);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var9.set(128, 55, false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);

  }

  public void test232() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test232");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var17 = var0.intersects(var10);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    var10.xor(var18);
    int var32 = var18.length();
    int var33 = var18.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);

  }

  public void test233() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test233");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    int var15 = var0.cardinality();
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    var20.set(0, true);
    var16.andNot(var20);
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    BitSet var44 = new BitSet();
    var41.xor(var44);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    BitSet var49 = new BitSet();
    var46.xor(var49);
    var41.and(var49);
    var49.flip(1);
    boolean var55 = var49.get(100);
    int var57 = var49.nextSetBit(1);
    var34.xor(var49);
    boolean var59 = var20.intersects(var49);
    var0.or(var20);
    java.lang.Object var61 = var0.clone();
    var0.flip(1, 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var61);

  }

  public void test234() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test234");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    int var24 = var11.nextSetBit(100);
    var11.set(100, false);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var11.set(64, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == (-1));

  }

  public void test235() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test235");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.set(0, true);
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    BitSet var26 = var9.get(64, 100);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var38 = var26.intersects(var31);
    var0.andNot(var31);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.flip(54, 10);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);

  }

  public void test236() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test236");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var11 = var0.isEmpty();
    var0.set(10, 100);
    var0.flip(0);
    var0.set(0, true);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var22 = var0.get(54, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);

  }

  public void test237() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test237");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    boolean var14 = var8.get(100);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    var15.flip(1);
    int var20 = var15.length();
    var15.set(1, 100);
    var8.or(var15);
    var15.set(100, true);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var15.clear(64, 10);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 2);

  }

  public void test238() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test238");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    boolean var33 = var9.intersects(var28);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var28.flip(64, 54);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);

  }

  public void test239() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test239");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var20 = var0.get(2, 128);
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    BitSet var24 = new BitSet();
    var21.xor(var24);
    int var26 = var24.length();
    var24.clear();
    boolean var28 = var20.intersects(var24);
    int var30 = var20.nextSetBit(65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var20);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == (-1));

  }

  public void test240() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test240");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.set(0, true);
    int var10 = var0.nextSetBit(64);
    BitSet var12 = new BitSet(10);
    var0.or(var12);
    BitSet var14 = new BitSet();
    int var15 = var14.length();
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    boolean var28 = var16.equals((java.lang.Object)(-1L));
    var16.flip(0);
    BitSet var33 = var16.get(64, 100);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    boolean var45 = var33.intersects(var38);
    var14.and(var33);
    java.lang.String var47 = var14.toString();
    var12.andNot(var14);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var33);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var47 + "' != '" + "{}"+ "'", var47.equals("{}"));

  }

  public void test241() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test241");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    int var13 = var9.cardinality();
    int var14 = var9.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == 54);

  }

  public void test242() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test242");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.set(0, true);
    int var23 = var13.nextSetBit(64);
    BitSet var25 = new BitSet(10);
    var13.or(var25);
    boolean var27 = var0.intersects(var13);
    boolean var28 = var13.isEmpty();
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    BitSet var32 = new BitSet();
    var29.xor(var32);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    BitSet var37 = new BitSet();
    var34.xor(var37);
    var29.and(var37);
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    BitSet var43 = new BitSet();
    var40.xor(var43);
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    BitSet var48 = new BitSet();
    var45.xor(var48);
    var40.and(var48);
    boolean var51 = var29.intersects(var40);
    int var53 = var40.nextSetBit(100);
    boolean var54 = var13.equals((java.lang.Object)var53);
    int var56 = var13.nextClearBit(10);
    var13.clear(64, 65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == 10);

  }

  public void test243() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test243");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    int var15 = var0.nextClearBit(0);
    java.lang.Object var16 = var0.clone();
    java.lang.Object var17 = var0.clone();
    int var19 = var0.nextClearBit(128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var16);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 128);

  }

  public void test244() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test244");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    int var15 = var0.cardinality();
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    var20.set(0, true);
    var16.andNot(var20);
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    BitSet var44 = new BitSet();
    var41.xor(var44);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    BitSet var49 = new BitSet();
    var46.xor(var49);
    var41.and(var49);
    var49.flip(1);
    boolean var55 = var49.get(100);
    int var57 = var49.nextSetBit(1);
    var34.xor(var49);
    boolean var59 = var20.intersects(var49);
    var0.or(var20);
    BitSet var61 = new BitSet();
    boolean var63 = var61.get(0);
    BitSet var64 = new BitSet();
    var61.xor(var64);
    BitSet var66 = new BitSet();
    boolean var68 = var66.get(0);
    BitSet var69 = new BitSet();
    var66.xor(var69);
    var61.and(var69);
    boolean var72 = var61.isEmpty();
    var61.clear(10, 10);
    var61.clear(64);
    var0.xor(var61);
    var61.set(10, 65, false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == true);

  }

  public void test245() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test245");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    boolean var14 = var0.get(64);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    boolean var21 = var18.equals((java.lang.Object)(-1L));
    BitSet var24 = var18.get(0, 1);
    var24.flip(10, 64);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    var36.flip(1);
    int var41 = var36.cardinality();
    var24.xor(var36);
    var24.clear(101);
    var0.and(var24);
    boolean var46 = var24.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);

  }

  public void test246() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test246");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var28.get(54);
    var28.set(64, true);
    int var41 = var28.nextSetBit(54);
    int var42 = var28.size();
    boolean var43 = var7.intersects(var28);
    int var44 = var28.length();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var47 = var28.get(2, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 101);

  }

  public void test247() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test247");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    BitSet var16 = new BitSet(0);
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    int var26 = var23.length();
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    var27.set(100, true);
    boolean var33 = var23.intersects(var27);
    boolean var35 = var23.equals((java.lang.Object)(-1L));
    var17.or(var23);
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    BitSet var40 = new BitSet();
    var37.xor(var40);
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    BitSet var45 = new BitSet();
    var42.xor(var45);
    var37.and(var45);
    var45.flip(1);
    boolean var51 = var45.get(100);
    int var52 = var45.size();
    int var53 = var45.cardinality();
    var23.xor(var45);
    var23.flip(0, 128);
    var16.xor(var23);
    var0.xor(var23);
    int var60 = var23.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == 127);

  }

  public void test248() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test248");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.set(0, true);
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    BitSet var26 = var9.get(64, 100);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var38 = var26.intersects(var31);
    var0.andNot(var31);
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    BitSet var43 = new BitSet();
    var40.xor(var43);
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    BitSet var48 = new BitSet();
    var45.xor(var48);
    var40.and(var48);
    boolean var51 = var40.isEmpty();
    var40.clear(10, 10);
    int var55 = var40.cardinality();
    java.lang.Object var56 = var40.clone();
    boolean var57 = var0.equals((java.lang.Object)var40);
    java.lang.String var58 = var40.toString();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var56);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var58 + "' != '" + "{}"+ "'", var58.equals("{}"));

  }

  public void test249() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test249");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    var9.flip(2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);

  }

  public void test250() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test250");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    var15.and(var23);
    var0.or(var23);
    boolean var27 = var0.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == true);

  }

  public void test251() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test251");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    boolean var7 = var0.equals((java.lang.Object)'a');
    java.lang.Object var8 = var0.clone();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var11 = var0.get(65, 10);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var8);

  }

  public void test252() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test252");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    int var15 = var0.length();
    int var16 = var0.cardinality();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    BitSet var20 = new BitSet();
    var17.xor(var20);
    boolean var23 = var20.equals((java.lang.Object)(-1L));
    BitSet var26 = var20.get(0, 1);
    var20.clear();
    var0.andNot(var20);
    int var29 = var0.length();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.flip(100, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 1);

  }

  public void test253() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test253");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    boolean var14 = var2.equals((java.lang.Object)(-1L));
    var2.flip(0);
    BitSet var19 = var2.get(64, 100);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    int var23 = var20.length();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    boolean var30 = var20.intersects(var24);
    boolean var31 = var19.intersects(var24);
    var0.and(var19);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set((-1), true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var19);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);

  }

  public void test254() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test254");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var28.get(54);
    var28.set(64, true);
    int var41 = var28.nextSetBit(54);
    int var42 = var28.size();
    boolean var43 = var7.intersects(var28);
    BitSet var44 = new BitSet();
    boolean var46 = var44.get(0);
    int var47 = var44.length();
    BitSet var48 = new BitSet();
    boolean var50 = var48.get(0);
    var48.set(100, true);
    boolean var54 = var44.intersects(var48);
    var44.set(0, 1);
    var28.andNot(var44);
    boolean var59 = var28.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);

  }

  public void test255() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test255");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var20 = var0.get(2, 128);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(127, 2);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var20);

  }

  public void test256() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test256");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    var0.clear(1);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    BitSet var9 = new BitSet();
    var6.xor(var9);
    boolean var12 = var9.equals((java.lang.Object)(-1L));
    BitSet var15 = var9.get(0, 1);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    int var27 = var20.cardinality();
    var15.andNot(var20);
    var0.xor(var15);
    var0.set(64);
    int var32 = var0.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == 128);

  }

  public void test257() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test257");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    var35.flip(1);
    boolean var41 = var35.get(100);
    int var43 = var35.nextSetBit(1);
    var20.xor(var35);
    var0.andNot(var35);
    java.lang.String var46 = var0.toString();
    BitSet var49 = var0.get(2, 101);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var52 = var0.get(90, 54);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var46 + "' != '" + "{64}"+ "'", var46.equals("{64}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var49);

  }

  public void test258() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test258");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.set(1, 100);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    BitSet var17 = new BitSet();
    var14.xor(var17);
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    BitSet var22 = new BitSet();
    var19.xor(var22);
    var14.and(var22);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    BitSet var33 = new BitSet();
    var30.xor(var33);
    var25.and(var33);
    boolean var36 = var14.intersects(var25);
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    BitSet var40 = new BitSet();
    var37.xor(var40);
    boolean var43 = var40.equals((java.lang.Object)(-1L));
    BitSet var44 = new BitSet();
    boolean var46 = var44.get(0);
    int var47 = var44.length();
    BitSet var48 = new BitSet();
    boolean var50 = var48.get(0);
    var48.set(100, true);
    boolean var54 = var44.intersects(var48);
    boolean var56 = var44.equals((java.lang.Object)(-1L));
    var44.flip(0);
    int var59 = var44.cardinality();
    boolean var60 = var40.intersects(var44);
    var14.and(var44);
    java.lang.String var62 = var14.toString();
    var8.and(var14);
    var8.set(90);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var62 + "' != '" + "{}"+ "'", var62.equals("{}"));

  }

  public void test259() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test259");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.set(64);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var30 = var26.nextClearBit(0);
    java.lang.Object var31 = var26.clone();
    var3.or(var26);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    int var36 = var33.length();
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    var37.set(100, true);
    boolean var43 = var33.intersects(var37);
    int var44 = var33.size();
    boolean var45 = var26.intersects(var33);
    int var47 = var26.nextSetBit(100);
    java.lang.Object var48 = var26.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var48);

  }

  public void test260() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test260");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    int var6 = var0.size();
    int var8 = var0.nextClearBit(65);
    boolean var9 = var0.isEmpty();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    int var13 = var10.length();
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    var14.set(100, true);
    boolean var20 = var10.intersects(var14);
    boolean var22 = var10.equals((java.lang.Object)(-1L));
    var10.flip(0);
    BitSet var27 = var10.get(64, 100);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    boolean var46 = var34.equals((java.lang.Object)(-1L));
    var28.or(var34);
    boolean var48 = var10.intersects(var34);
    int var49 = var34.size();
    BitSet var50 = new BitSet();
    boolean var52 = var50.get(0);
    var50.set(100, true);
    boolean var57 = var50.equals((java.lang.Object)'a');
    boolean var58 = var34.intersects(var50);
    boolean var59 = var34.isEmpty();
    boolean var60 = var0.intersects(var34);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == 65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var27);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);

  }

  public void test261() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test261");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.set(0, true);
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    BitSet var26 = var9.get(64, 100);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var38 = var26.intersects(var31);
    var0.andNot(var31);
    boolean var41 = var31.get(54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);

  }

  public void test262() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test262");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var7.clear(2);
    int var26 = var7.cardinality();
    var7.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);

  }

  public void test263() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test263");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var29 = var17.intersects(var22);
    boolean var30 = var22.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);

  }

  public void test264() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test264");


    BitSet var1 = new BitSet(0);
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    var2.set(100, true);
    BitSet var8 = new BitSet();
    boolean var10 = var8.get(0);
    int var11 = var8.length();
    BitSet var12 = new BitSet();
    boolean var14 = var12.get(0);
    var12.set(100, true);
    boolean var18 = var8.intersects(var12);
    boolean var20 = var8.equals((java.lang.Object)(-1L));
    var2.or(var8);
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    BitSet var25 = new BitSet();
    var22.xor(var25);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    var22.and(var30);
    var30.flip(1);
    boolean var36 = var30.get(100);
    int var37 = var30.size();
    int var38 = var30.cardinality();
    var8.xor(var30);
    var8.flip(0, 128);
    var1.xor(var8);
    boolean var44 = var8.isEmpty();
    int var45 = var8.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 127);

  }

  public void test265() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test265");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var20 = var0.get(2, 128);
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    BitSet var24 = new BitSet();
    var21.xor(var24);
    int var26 = var24.length();
    var24.clear();
    boolean var28 = var20.intersects(var24);
    var20.set(10, true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var20);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);

  }

  public void test266() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test266");


    BitSet var1 = new BitSet(101);
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    var2.set(100, true);
    var2.clear(1, 100);
    boolean var11 = var2.isEmpty();
    var1.andNot(var2);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.set(0, true);
    var13.set(0, true);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    boolean var34 = var31.equals((java.lang.Object)(-1L));
    BitSet var37 = var31.get(0, 1);
    var37.flip(10, 64);
    int var41 = var37.cardinality();
    var25.xor(var37);
    BitSet var44 = new BitSet(0);
    var25.andNot(var44);
    var13.xor(var44);
    var1.xor(var44);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var37);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 54);

  }

  public void test267() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test267");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var3.clear();
    int var11 = var3.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);

  }

  public void test268() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test268");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var13.clear(1);
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    BitSet var20 = new BitSet();
    var17.xor(var20);
    boolean var23 = var20.equals((java.lang.Object)(-1L));
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var24.equals((java.lang.Object)(-1L));
    var24.flip(0);
    int var39 = var24.cardinality();
    boolean var40 = var20.intersects(var24);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    int var44 = var41.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    boolean var51 = var41.intersects(var45);
    boolean var53 = var45.get(54);
    var45.set(64, true);
    int var58 = var45.nextSetBit(54);
    int var59 = var45.size();
    boolean var60 = var24.intersects(var45);
    var13.xor(var45);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var64 = var45.get(54, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);

  }

  public void test269() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test269");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    int var12 = var0.size();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    int var16 = var13.length();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    boolean var23 = var13.intersects(var17);
    boolean var24 = var13.isEmpty();
    var13.set(10, 100);
    var0.xor(var13);
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    var29.set(100, true);
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    int var38 = var35.length();
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    var39.set(100, true);
    boolean var45 = var35.intersects(var39);
    boolean var46 = var29.intersects(var39);
    BitSet var47 = new BitSet();
    boolean var49 = var47.get(0);
    int var50 = var47.length();
    BitSet var51 = new BitSet();
    boolean var53 = var51.get(0);
    var51.set(100, true);
    boolean var57 = var47.intersects(var51);
    boolean var59 = var47.equals((java.lang.Object)(-1L));
    var39.xor(var47);
    boolean var61 = var13.equals((java.lang.Object)var39);
    boolean var62 = var13.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);

  }

  public void test270() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test270");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.set(0, true);
    int var23 = var13.nextSetBit(64);
    BitSet var25 = new BitSet(10);
    var13.or(var25);
    boolean var27 = var0.intersects(var13);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    boolean var39 = var28.isEmpty();
    int var40 = var28.size();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    int var44 = var41.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    boolean var51 = var41.intersects(var45);
    boolean var52 = var41.isEmpty();
    var41.set(10, 100);
    var28.xor(var41);
    int var58 = var28.nextClearBit(10);
    boolean var59 = var13.intersects(var28);
    BitSet var60 = new BitSet();
    boolean var62 = var60.get(0);
    BitSet var63 = new BitSet();
    var60.xor(var63);
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    BitSet var68 = new BitSet();
    var65.xor(var68);
    var60.and(var68);
    var60.set(10);
    boolean var73 = var28.equals((java.lang.Object)var60);
    BitSet var74 = new BitSet();
    boolean var76 = var74.get(0);
    int var77 = var74.length();
    BitSet var78 = new BitSet();
    boolean var80 = var78.get(0);
    var78.set(100, true);
    boolean var84 = var74.intersects(var78);
    boolean var85 = var74.isEmpty();
    boolean var86 = var60.equals((java.lang.Object)var74);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var74.set(127, 90);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var76 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var77 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var80 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var86 == false);

  }

  public void test271() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test271");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.set(1, 100);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    boolean var33 = var14.get(54);
    var8.and(var14);
    var14.clear(65, 101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);

  }

  public void test272() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test272");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    int var13 = var8.cardinality();
    java.lang.Object var14 = var8.clone();
    java.lang.Object var15 = var8.clone();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var8.clear(100, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var14);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);

  }

  public void test273() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test273");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.flip(1, 1);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var39 = var27.equals((java.lang.Object)(-1L));
    BitSet var42 = var27.get(1, 100);
    var3.or(var27);
    int var44 = var27.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    int var48 = var45.length();
    BitSet var49 = new BitSet();
    boolean var51 = var49.get(0);
    var49.set(100, true);
    var49.set(0, true);
    var45.andNot(var49);
    BitSet var59 = new BitSet();
    boolean var61 = var59.get(0);
    int var62 = var59.length();
    BitSet var63 = new BitSet();
    boolean var65 = var63.get(0);
    var63.set(100, true);
    boolean var69 = var59.intersects(var63);
    boolean var71 = var59.equals((java.lang.Object)(-1L));
    var59.flip(0);
    BitSet var76 = var59.get(64, 100);
    BitSet var77 = new BitSet();
    boolean var79 = var77.get(0);
    int var80 = var77.length();
    BitSet var81 = new BitSet();
    boolean var83 = var81.get(0);
    var81.set(100, true);
    boolean var87 = var77.intersects(var81);
    boolean var88 = var76.intersects(var81);
    boolean var89 = var45.equals((java.lang.Object)var76);
    var27.xor(var76);
    var27.flip(64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var42);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var76);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var79 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var80 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var83 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var87 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var88 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var89 == true);

  }

  public void test274() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test274");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    boolean var12 = var0.isEmpty();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    boolean var19 = var16.equals((java.lang.Object)(-1L));
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    int var23 = var20.length();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    boolean var30 = var20.intersects(var24);
    boolean var32 = var20.equals((java.lang.Object)(-1L));
    var20.flip(0);
    int var35 = var20.cardinality();
    boolean var36 = var16.intersects(var20);
    var20.set(54, true);
    int var40 = var20.length();
    boolean var41 = var0.intersects(var20);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 55);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);

  }

  public void test275() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test275");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    int var5 = var0.length();
    var0.set(1, 100);
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    BitSet var12 = new BitSet();
    var9.xor(var12);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    BitSet var17 = new BitSet();
    var14.xor(var17);
    var9.and(var17);
    var17.flip(1);
    BitSet var22 = new BitSet();
    var17.or(var22);
    var17.clear(64, 64);
    boolean var28 = var17.get(54);
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    var29.set(100, true);
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    int var38 = var35.length();
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    var39.set(100, true);
    boolean var45 = var35.intersects(var39);
    boolean var46 = var29.intersects(var39);
    BitSet var47 = new BitSet();
    boolean var49 = var47.get(0);
    int var50 = var47.length();
    BitSet var51 = new BitSet();
    boolean var53 = var51.get(0);
    var51.set(100, true);
    boolean var57 = var47.intersects(var51);
    boolean var59 = var47.equals((java.lang.Object)(-1L));
    var39.xor(var47);
    int var61 = var47.length();
    boolean var62 = var17.equals((java.lang.Object)var61);
    var17.set(55, 65);
    var0.andNot(var17);
    int var67 = var17.length();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var17.clear(54, 0);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == 65);

  }

  public void test276() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test276");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var20 = var0.get(2, 128);
    var20.set(1, 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var20);

  }

  public void test277() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test277");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    var0.clear(0, 1);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(54, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);

  }

  public void test278() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test278");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    var35.flip(1);
    boolean var41 = var35.get(100);
    int var43 = var35.nextSetBit(1);
    var20.xor(var35);
    var0.andNot(var35);
    java.lang.String var46 = var0.toString();
    BitSet var49 = var0.get(2, 101);
    var49.flip(54, 101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var46 + "' != '" + "{64}"+ "'", var46.equals("{64}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var49);

  }

  public void test279() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test279");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    int var15 = var0.nextClearBit(0);
    java.lang.Object var16 = var0.clone();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(101, 2, false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var16);

  }

  public void test280() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test280");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    var9.clear();
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    int var25 = var14.size();
    java.lang.Object var26 = var14.clone();
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    var27.set(100, true);
    var27.set(0, true);
    int var37 = var27.nextSetBit(64);
    BitSet var39 = new BitSet(10);
    var27.or(var39);
    boolean var41 = var14.intersects(var27);
    boolean var42 = var27.isEmpty();
    var9.or(var27);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var9.set(1, (-1), false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);

  }

  public void test281() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test281");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    boolean var21 = var18.equals((java.lang.Object)(-1L));
    BitSet var24 = var18.get(0, 1);
    var24.flip(64, 100);
    var24.flip(0);
    boolean var30 = var0.intersects(var24);
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    int var35 = var31.nextClearBit(0);
    java.lang.Object var36 = var31.clone();
    var31.flip(54);
    BitSet var40 = new BitSet(54);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    BitSet var44 = new BitSet();
    var41.xor(var44);
    boolean var47 = var44.equals((java.lang.Object)(-1L));
    BitSet var48 = new BitSet();
    boolean var50 = var48.get(0);
    int var51 = var48.length();
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    var52.set(100, true);
    boolean var58 = var48.intersects(var52);
    boolean var60 = var48.equals((java.lang.Object)(-1L));
    var48.flip(0);
    int var63 = var48.cardinality();
    boolean var64 = var44.intersects(var48);
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    int var68 = var65.length();
    BitSet var69 = new BitSet();
    boolean var71 = var69.get(0);
    var69.set(100, true);
    boolean var75 = var65.intersects(var69);
    boolean var77 = var69.get(54);
    var69.set(64, true);
    int var82 = var69.nextSetBit(54);
    int var83 = var69.size();
    boolean var84 = var48.intersects(var69);
    var40.andNot(var69);
    var31.or(var40);
    boolean var87 = var31.isEmpty();
    var24.xor(var31);
    BitSet var89 = new BitSet();
    boolean var91 = var89.get(0);
    var89.set(100, true);
    var89.clear(1, 100);
    java.lang.Object var98 = var89.clone();
    var24.xor(var89);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var36);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var77 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var82 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var83 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var87 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var91 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var98);

  }

  public void test282() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test282");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    int var34 = var31.length();
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    var35.set(100, true);
    var35.set(0, true);
    var31.andNot(var35);
    var31.flip(64);
    var31.set(100, false);
    var18.xor(var31);
    boolean var51 = var0.intersects(var31);
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    BitSet var55 = new BitSet();
    var52.xor(var55);
    BitSet var57 = new BitSet();
    boolean var59 = var57.get(0);
    BitSet var60 = new BitSet();
    var57.xor(var60);
    var52.and(var60);
    int var63 = var52.cardinality();
    var52.clear();
    java.lang.String var65 = var52.toString();
    java.lang.String var66 = var52.toString();
    int var67 = var52.length();
    BitSet var68 = new BitSet();
    boolean var70 = var68.get(0);
    BitSet var71 = new BitSet();
    var68.xor(var71);
    BitSet var73 = new BitSet();
    boolean var75 = var73.get(0);
    BitSet var76 = new BitSet();
    var73.xor(var76);
    var68.and(var76);
    var76.set(1, 100);
    var52.and(var76);
    boolean var83 = var0.equals((java.lang.Object)var52);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var65 + "' != '" + "{}"+ "'", var65.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var66 + "' != '" + "{}"+ "'", var66.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var83 == false);

  }

  public void test283() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test283");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    var35.flip(1);
    boolean var41 = var35.get(100);
    int var43 = var35.nextSetBit(1);
    var20.xor(var35);
    var0.andNot(var35);
    java.lang.String var46 = var0.toString();
    BitSet var49 = var0.get(2, 101);
    boolean var51 = var0.get(0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var46 + "' != '" + "{64}"+ "'", var46.equals("{64}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var49);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);

  }

  public void test284() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test284");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear(100);
    int var14 = var0.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == 0);

  }

  public void test285() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test285");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    var0.clear(0, 0);
    var0.clear(64);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(65, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);

  }

  public void test286() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test286");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var29 = var17.intersects(var22);
    var17.clear(64, 64);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    int var36 = var33.length();
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    var37.set(100, true);
    boolean var43 = var33.intersects(var37);
    boolean var45 = var33.equals((java.lang.Object)(-1L));
    var17.or(var33);
    BitSet var48 = new BitSet(0);
    BitSet var49 = new BitSet();
    boolean var51 = var49.get(0);
    var49.set(100, true);
    BitSet var55 = new BitSet();
    boolean var57 = var55.get(0);
    int var58 = var55.length();
    BitSet var59 = new BitSet();
    boolean var61 = var59.get(0);
    var59.set(100, true);
    boolean var65 = var55.intersects(var59);
    boolean var67 = var55.equals((java.lang.Object)(-1L));
    var49.or(var55);
    BitSet var69 = new BitSet();
    boolean var71 = var69.get(0);
    BitSet var72 = new BitSet();
    var69.xor(var72);
    BitSet var74 = new BitSet();
    boolean var76 = var74.get(0);
    BitSet var77 = new BitSet();
    var74.xor(var77);
    var69.and(var77);
    var77.flip(1);
    boolean var83 = var77.get(100);
    int var84 = var77.size();
    int var85 = var77.cardinality();
    var55.xor(var77);
    var55.flip(0, 128);
    var48.xor(var55);
    int var92 = var55.nextSetBit(65);
    var17.and(var55);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var76 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var83 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var92 == 65);

  }

  public void test287() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test287");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    boolean var5 = var3.get(0);
    BitSet var6 = new BitSet();
    var3.xor(var6);
    boolean var9 = var6.equals((java.lang.Object)(-1L));
    BitSet var12 = var6.get(0, 1);
    var12.flip(10, 64);
    int var16 = var12.cardinality();
    var0.xor(var12);
    int var18 = var0.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 64);

  }

  public void test288() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test288");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    boolean var14 = var2.equals((java.lang.Object)(-1L));
    var2.flip(0);
    BitSet var19 = var2.get(64, 100);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    int var23 = var20.length();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    boolean var30 = var20.intersects(var24);
    boolean var31 = var19.intersects(var24);
    var0.and(var19);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    var33.set(100, true);
    var33.clear(1, 100);
    int var43 = var33.nextSetBit(1);
    int var45 = var33.nextClearBit(1);
    var0.xor(var33);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(54, 2);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var19);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);

  }

  public void test289() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test289");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    boolean var25 = var3.get(128);
    var3.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);

  }

  public void test290() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test290");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.clear(1, 100);
    int var10 = var0.nextSetBit(1);
    int var12 = var0.nextClearBit(100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 101);

  }

  public void test291() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test291");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    boolean var14 = var8.get(100);
    int var16 = var8.nextSetBit(1);
    BitSet var19 = var8.get(1, 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var19);

  }

  public void test292() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test292");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    java.lang.String var28 = var21.toString();
    var21.clear(1);
    var21.clear(1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var28 + "' != '" + "{1}"+ "'", var28.equals("{1}"));

  }

  public void test293() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test293");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    int var16 = var13.length();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    boolean var23 = var13.intersects(var17);
    boolean var25 = var13.equals((java.lang.Object)(-1L));
    var13.flip(0);
    BitSet var30 = var13.get(64, 100);
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    int var40 = var37.length();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    var41.set(100, true);
    boolean var47 = var37.intersects(var41);
    boolean var49 = var37.equals((java.lang.Object)(-1L));
    var31.or(var37);
    boolean var51 = var13.intersects(var37);
    int var52 = var37.size();
    BitSet var53 = new BitSet();
    boolean var55 = var53.get(0);
    var53.set(100, true);
    boolean var60 = var53.equals((java.lang.Object)'a');
    boolean var61 = var37.intersects(var53);
    boolean var62 = var0.equals((java.lang.Object)var53);
    var0.clear(128);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(55, (-1), false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var30);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);

  }

  public void test294() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test294");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    java.lang.Object var5 = var0.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var5);

  }

  public void test295() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test295");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    var0.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);

  }

  public void test296() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test296");


    BitSet var1 = new BitSet(128);
    var1.set(127);

  }

  public void test297() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test297");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    var0.clear(1);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    BitSet var9 = new BitSet();
    var6.xor(var9);
    boolean var12 = var9.equals((java.lang.Object)(-1L));
    BitSet var15 = var9.get(0, 1);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    int var27 = var20.cardinality();
    var15.andNot(var20);
    var0.xor(var15);
    boolean var30 = var15.isEmpty();
    var15.set(64, 128);
    var15.set(127);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == true);

  }

  public void test298() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test298");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    int var18 = var15.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    var19.set(100, true);
    boolean var25 = var15.intersects(var19);
    boolean var27 = var15.equals((java.lang.Object)(-1L));
    var15.flip(0);
    BitSet var32 = var15.get(64, 100);
    var0.or(var15);
    int var34 = var15.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var32);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 1);

  }

  public void test299() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test299");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    var15.set(100, true);
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    int var24 = var21.length();
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    var25.set(100, true);
    boolean var31 = var21.intersects(var25);
    boolean var33 = var21.equals((java.lang.Object)(-1L));
    var15.or(var21);
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    BitSet var38 = new BitSet();
    var35.xor(var38);
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    BitSet var43 = new BitSet();
    var40.xor(var43);
    var35.and(var43);
    var43.flip(1);
    boolean var49 = var43.get(100);
    int var50 = var43.size();
    int var51 = var43.cardinality();
    var21.xor(var43);
    java.lang.String var53 = var43.toString();
    boolean var54 = var0.equals((java.lang.Object)var43);
    int var55 = var43.length();
    var43.clear(0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var53 + "' != '" + "{1}"+ "'", var53.equals("{1}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 2);

  }

  public void test300() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test300");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    var0.flip(0);
    java.lang.String var4 = var0.toString();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var4 + "' != '" + "{0}"+ "'", var4.equals("{0}"));

  }

  public void test301() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test301");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    boolean var29 = var26.equals((java.lang.Object)(-1L));
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    boolean var42 = var30.equals((java.lang.Object)(-1L));
    var30.flip(0);
    int var45 = var30.cardinality();
    boolean var46 = var26.intersects(var30);
    var0.and(var30);
    int var49 = var0.nextSetBit(1);
    java.lang.Object var50 = var0.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var50);

  }

  public void test302() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test302");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var0.or(var13);
    int var20 = var0.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 128);

  }

  public void test303() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test303");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.clear(1, 100);
    int var9 = var0.cardinality();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    int var13 = var10.length();
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    var14.set(100, true);
    boolean var20 = var10.intersects(var14);
    var10.set(0, 1);
    var0.xor(var10);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    int var28 = var25.length();
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    var29.set(100, true);
    boolean var35 = var25.intersects(var29);
    boolean var37 = var25.equals((java.lang.Object)(-1L));
    var25.flip(0);
    BitSet var42 = var25.get(64, 100);
    BitSet var43 = new BitSet();
    boolean var45 = var43.get(0);
    int var46 = var43.length();
    BitSet var47 = new BitSet();
    boolean var49 = var47.get(0);
    var47.set(100, true);
    boolean var53 = var43.intersects(var47);
    boolean var55 = var43.equals((java.lang.Object)(-1L));
    BitSet var56 = new BitSet();
    boolean var58 = var56.get(0);
    int var59 = var56.length();
    BitSet var60 = new BitSet();
    boolean var62 = var60.get(0);
    var60.set(100, true);
    var60.set(0, true);
    var56.andNot(var60);
    var56.flip(64);
    var56.set(100, false);
    var43.xor(var56);
    boolean var76 = var25.intersects(var56);
    BitSet var77 = new BitSet();
    boolean var79 = var77.get(0);
    int var81 = var77.nextClearBit(0);
    var25.or(var77);
    var0.and(var77);
    int var84 = var77.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var42);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var76 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var79 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var81 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == 0);

  }

  public void test304() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test304");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    var0.clear(0, 0);
    var0.set(127, true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);

  }

  public void test305() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test305");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    int var18 = var15.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    var19.set(100, true);
    boolean var25 = var15.intersects(var19);
    boolean var27 = var15.equals((java.lang.Object)(-1L));
    var15.flip(0);
    BitSet var32 = var15.get(64, 100);
    var0.or(var15);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    int var45 = var38.cardinality();
    var0.xor(var38);
    int var47 = var0.length();
    java.lang.Object var48 = var0.clone();
    BitSet var49 = new BitSet();
    boolean var51 = var49.get(0);
    int var52 = var49.length();
    BitSet var53 = new BitSet();
    boolean var55 = var53.get(0);
    var53.set(100, true);
    boolean var59 = var49.intersects(var53);
    boolean var61 = var49.equals((java.lang.Object)(-1L));
    var49.flip(0);
    boolean var64 = var49.isEmpty();
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    BitSet var68 = new BitSet();
    var65.xor(var68);
    BitSet var70 = new BitSet();
    boolean var72 = var70.get(0);
    BitSet var73 = new BitSet();
    var70.xor(var73);
    var65.and(var73);
    var73.flip(1);
    BitSet var78 = new BitSet();
    var73.or(var78);
    var73.clear(64, 64);
    boolean var84 = var73.get(54);
    var49.or(var73);
    boolean var86 = var0.intersects(var73);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var32);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == 101);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var48);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var86 == false);

  }

  public void test306() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test306");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var28.get(54);
    var28.set(64, true);
    int var41 = var28.nextSetBit(54);
    int var42 = var28.size();
    boolean var43 = var7.intersects(var28);
    int var44 = var28.length();
    boolean var45 = var28.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);

  }

  public void test307() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test307");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    var9.clear();
    java.lang.String var14 = var9.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    boolean var21 = var18.equals((java.lang.Object)(-1L));
    BitSet var24 = var18.get(0, 1);
    var9.xor(var18);
    var9.flip(1, 100);
    BitSet var29 = new BitSet();
    int var30 = var29.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    int var34 = var31.length();
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    var35.set(100, true);
    boolean var41 = var31.intersects(var35);
    int var42 = var31.size();
    var29.or(var31);
    int var45 = var29.nextSetBit(10);
    var9.and(var29);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == (-1));

  }

  public void test308() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test308");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    int var29 = var9.nextClearBit(10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 64);

  }

  public void test309() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test309");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var19 = var0.get(54);
    int var20 = var0.length();
    int var21 = var0.cardinality();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    int var31 = var28.length();
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    var32.set(100, true);
    boolean var38 = var28.intersects(var32);
    boolean var40 = var28.equals((java.lang.Object)(-1L));
    var22.or(var28);
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    BitSet var45 = new BitSet();
    var42.xor(var45);
    BitSet var47 = new BitSet();
    boolean var49 = var47.get(0);
    BitSet var50 = new BitSet();
    var47.xor(var50);
    var42.and(var50);
    var50.flip(1);
    boolean var56 = var50.get(100);
    int var57 = var50.size();
    int var58 = var50.cardinality();
    var28.xor(var50);
    java.lang.String var60 = var50.toString();
    boolean var61 = var0.intersects(var50);
    boolean var62 = var0.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var60 + "' != '" + "{1}"+ "'", var60.equals("{1}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);

  }

  public void test310() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test310");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    var4.clear();
    int var13 = var4.nextSetBit(64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == (-1));

  }

  public void test311() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test311");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.set(0, true);
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    BitSet var26 = var9.get(64, 100);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var38 = var26.intersects(var31);
    var0.andNot(var31);
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    BitSet var43 = new BitSet();
    var40.xor(var43);
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    BitSet var48 = new BitSet();
    var45.xor(var48);
    var40.and(var48);
    boolean var51 = var40.isEmpty();
    var40.clear(10, 10);
    int var55 = var40.cardinality();
    java.lang.Object var56 = var40.clone();
    boolean var57 = var0.equals((java.lang.Object)var40);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(127, 101);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var56);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);

  }

  public void test312() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test312");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var8.clear(64, 64);
    boolean var19 = var8.get(54);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var29 = var26.length();
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    var30.set(100, true);
    boolean var36 = var26.intersects(var30);
    boolean var37 = var20.intersects(var30);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    int var41 = var38.length();
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    var42.set(100, true);
    boolean var48 = var38.intersects(var42);
    boolean var50 = var38.equals((java.lang.Object)(-1L));
    var30.xor(var38);
    int var52 = var38.length();
    boolean var53 = var8.equals((java.lang.Object)var52);
    var8.set(55, 65);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var8.flip((-1), 90);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);

  }

  public void test313() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test313");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var3.clear();
    var3.clear(1);
    var3.flip(65, 128);
    var3.flip(90);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    int var29 = var18.size();
    var18.clear(64);
    int var32 = var18.length();
    var3.xor(var18);
    var18.clear(65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == 0);

  }

  public void test314() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test314");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    int var5 = var0.nextSetBit(90);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == (-1));

  }

  public void test315() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test315");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    java.lang.String var28 = var21.toString();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      int var30 = var21.nextSetBit((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var28 + "' != '" + "{1}"+ "'", var28.equals("{1}"));

  }

  public void test316() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test316");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    boolean var29 = var26.equals((java.lang.Object)(-1L));
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    boolean var42 = var30.equals((java.lang.Object)(-1L));
    var30.flip(0);
    int var45 = var30.cardinality();
    boolean var46 = var26.intersects(var30);
    var0.and(var30);
    int var49 = var0.nextSetBit(1);
    BitSet var50 = new BitSet();
    boolean var52 = var50.get(0);
    BitSet var53 = new BitSet();
    var50.xor(var53);
    boolean var56 = var53.equals((java.lang.Object)(-1L));
    BitSet var59 = var53.get(0, 1);
    var59.flip(10, 64);
    var59.clear();
    java.lang.String var64 = var59.toString();
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    BitSet var68 = new BitSet();
    var65.xor(var68);
    boolean var71 = var68.equals((java.lang.Object)(-1L));
    BitSet var74 = var68.get(0, 1);
    var59.xor(var68);
    BitSet var78 = var68.get(0, 65);
    java.lang.Object var79 = var78.clone();
    boolean var80 = var0.intersects(var78);
    java.lang.Object var81 = var78.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var59);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var64 + "' != '" + "{}"+ "'", var64.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var74);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var78);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var79);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var80 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var81);

  }

  public void test317() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test317");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    var18.and(var26);
    var26.flip(1);
    boolean var32 = var26.get(100);
    int var33 = var26.size();
    java.lang.Object var34 = var26.clone();
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    var35.set(100, true);
    int var41 = var35.size();
    var26.and(var35);
    var0.or(var26);
    java.lang.String var44 = var26.toString();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var34);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var44 + "' != '" + "{}"+ "'", var44.equals("{}"));

  }

  public void test318() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test318");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    int var13 = var0.cardinality();
    boolean var14 = var0.isEmpty();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    int var18 = var15.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    var19.set(100, true);
    boolean var25 = var15.intersects(var19);
    boolean var27 = var15.equals((java.lang.Object)(-1L));
    var15.flip(0);
    BitSet var32 = var15.get(64, 100);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    int var36 = var33.length();
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    var37.set(100, true);
    boolean var43 = var33.intersects(var37);
    boolean var44 = var32.intersects(var37);
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    int var48 = var45.length();
    BitSet var49 = new BitSet();
    boolean var51 = var49.get(0);
    var49.set(100, true);
    boolean var55 = var45.intersects(var49);
    boolean var57 = var45.equals((java.lang.Object)(-1L));
    var45.flip(0);
    int var60 = var45.length();
    boolean var61 = var32.equals((java.lang.Object)var45);
    var0.or(var45);
    boolean var63 = var0.isEmpty();
    BitSet var64 = new BitSet();
    boolean var66 = var64.get(0);
    int var67 = var64.length();
    BitSet var68 = new BitSet();
    boolean var70 = var68.get(0);
    var68.set(100, true);
    boolean var74 = var64.intersects(var68);
    boolean var75 = var64.isEmpty();
    var64.set(10, 100);
    var64.flip(0);
    var64.set(0, true);
    var0.andNot(var64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var32);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var74 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == true);

  }

  public void test319() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test319");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    int var15 = var0.length();
    int var16 = var0.cardinality();
    int var17 = var0.length();
    var0.set(64, 64, false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 1);

  }

  public void test320() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test320");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var0.set(100, false);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    BitSet var17 = new BitSet();
    var14.xor(var17);
    boolean var20 = var17.equals((java.lang.Object)(-1L));
    var0.andNot(var17);
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    boolean var31 = var28.equals((java.lang.Object)(-1L));
    BitSet var34 = var28.get(0, 1);
    var34.flip(10, 64);
    int var38 = var34.cardinality();
    var22.xor(var34);
    var0.xor(var34);
    int var41 = var0.size();
    int var43 = var0.nextClearBit(0);
    var0.clear(0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var34);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == 54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 0);

  }

  public void test321() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test321");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    boolean var12 = var0.isEmpty();
    var0.set(65, true);
    int var16 = var0.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 128);

  }

  public void test322() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test322");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.set(1, 100);
    var8.clear(128);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    BitSet var24 = new BitSet();
    var21.xor(var24);
    var16.and(var24);
    var24.flip(1);
    boolean var30 = var24.get(100);
    int var31 = var24.size();
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    var32.set(100, true);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    int var41 = var38.length();
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    var42.set(100, true);
    boolean var48 = var38.intersects(var42);
    boolean var49 = var32.intersects(var42);
    BitSet var50 = new BitSet();
    boolean var52 = var50.get(0);
    int var53 = var50.length();
    BitSet var54 = new BitSet();
    boolean var56 = var54.get(0);
    var54.set(100, true);
    boolean var60 = var50.intersects(var54);
    boolean var62 = var50.equals((java.lang.Object)(-1L));
    var42.xor(var50);
    var42.set(1, true);
    boolean var67 = var24.equals((java.lang.Object)true);
    var8.or(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);

  }

  public void test323() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test323");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var13.clear(1);
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    BitSet var20 = new BitSet();
    var17.xor(var20);
    boolean var23 = var20.equals((java.lang.Object)(-1L));
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var24.equals((java.lang.Object)(-1L));
    var24.flip(0);
    int var39 = var24.cardinality();
    boolean var40 = var20.intersects(var24);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    int var44 = var41.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    boolean var51 = var41.intersects(var45);
    boolean var53 = var45.get(54);
    var45.set(64, true);
    int var58 = var45.nextSetBit(54);
    int var59 = var45.size();
    boolean var60 = var24.intersects(var45);
    var13.xor(var45);
    BitSet var62 = new BitSet();
    boolean var64 = var62.get(0);
    BitSet var65 = new BitSet();
    var62.xor(var65);
    boolean var68 = var65.equals((java.lang.Object)(-1L));
    BitSet var71 = var65.get(0, 1);
    var71.flip(64, 100);
    var45.andNot(var71);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var45.flip(10, 2);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var71);

  }

  public void test324() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test324");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var6.set((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);

  }

  public void test325() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test325");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    int var35 = var32.length();
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    var36.set(100, true);
    boolean var42 = var32.intersects(var36);
    boolean var43 = var31.intersects(var36);
    boolean var44 = var0.equals((java.lang.Object)var31);
    BitSet var47 = var0.get(10, 64);
    var0.clear(0, 90);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var47);

  }

  public void test326() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test326");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var8.clear(64, 64);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    int var31 = var18.cardinality();
    java.lang.String var32 = var18.toString();
    var8.or(var18);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var36 = var8.get(100, 0);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var32 + "' != '" + "{}"+ "'", var32.equals("{}"));

  }

  public void test327() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test327");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var29 = var17.intersects(var22);
    var17.flip(65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);

  }

  public void test328() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test328");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    var0.clear(64);
    var0.flip(90, 128);
    BitSet var18 = new BitSet(90);
    var0.xor(var18);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);

  }

  public void test329() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test329");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    java.lang.String var11 = var0.toString();
    int var12 = var0.size();
    var0.set(128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var11 + "' != '" + "{}"+ "'", var11.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 64);

  }

  public void test330() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test330");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var20 = var0.get(2, 128);
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    BitSet var24 = new BitSet();
    var21.xor(var24);
    int var26 = var24.length();
    var24.clear();
    boolean var28 = var20.intersects(var24);
    java.lang.Object var29 = var24.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var20);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var29);

  }

  public void test331() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test331");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    var0.clear(64);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(100, 55);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);

  }

  public void test332() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test332");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    var0.clear(1);
    int var7 = var0.nextSetBit(64);
    int var9 = var0.nextClearBit(64);
    BitSet var12 = var0.get(55, 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);

  }

  public void test333() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test333");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    int var18 = var0.cardinality();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(90, 2, true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 1);

  }

  public void test334() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test334");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var8.clear(64, 64);
    boolean var19 = var8.get(54);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var29 = var26.length();
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    var30.set(100, true);
    boolean var36 = var26.intersects(var30);
    boolean var37 = var20.intersects(var30);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    int var41 = var38.length();
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    var42.set(100, true);
    boolean var48 = var38.intersects(var42);
    boolean var50 = var38.equals((java.lang.Object)(-1L));
    var30.xor(var38);
    int var52 = var38.length();
    boolean var53 = var8.equals((java.lang.Object)var52);
    var8.set(55, 65);
    var8.flip(0);
    boolean var60 = var8.get(90);
    BitSet var61 = new BitSet();
    boolean var63 = var61.get(0);
    int var64 = var61.length();
    var61.clear(1);
    BitSet var67 = new BitSet();
    boolean var69 = var67.get(0);
    BitSet var70 = new BitSet();
    var67.xor(var70);
    boolean var73 = var70.equals((java.lang.Object)(-1L));
    BitSet var76 = var70.get(0, 1);
    BitSet var77 = new BitSet();
    boolean var79 = var77.get(0);
    int var80 = var77.length();
    BitSet var81 = new BitSet();
    boolean var83 = var81.get(0);
    var81.set(100, true);
    boolean var87 = var77.intersects(var81);
    int var88 = var81.cardinality();
    var76.andNot(var81);
    var61.xor(var76);
    boolean var91 = var8.intersects(var76);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var76);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var79 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var80 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var83 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var87 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var88 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var91 == false);

  }

  public void test335() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test335");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var4.cardinality();
    int var13 = var4.nextSetBit(64);
    var4.set(2, true);
    boolean var17 = var4.isEmpty();
    var4.clear(55);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);

  }

  public void test336() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test336");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    boolean var14 = var8.get(100);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    boolean var21 = var18.equals((java.lang.Object)(-1L));
    BitSet var24 = var18.get(0, 1);
    var24.flip(10, 64);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    var36.flip(1);
    int var41 = var36.cardinality();
    var24.xor(var36);
    var36.set(0, false);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    BitSet var49 = new BitSet();
    var46.xor(var49);
    BitSet var51 = new BitSet();
    boolean var53 = var51.get(0);
    BitSet var54 = new BitSet();
    var51.xor(var54);
    var46.and(var54);
    boolean var57 = var46.isEmpty();
    var46.clear(10, 10);
    int var61 = var46.cardinality();
    int var62 = var46.length();
    boolean var63 = var36.equals((java.lang.Object)var46);
    var8.andNot(var46);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);

  }

  public void test337() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test337");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    var9.clear();
    java.lang.String var14 = var9.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    boolean var21 = var18.equals((java.lang.Object)(-1L));
    BitSet var24 = var18.get(0, 1);
    var9.xor(var18);
    BitSet var28 = var18.get(0, 65);
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    int var32 = var29.length();
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    var33.set(100, true);
    boolean var39 = var29.intersects(var33);
    boolean var41 = var29.equals((java.lang.Object)(-1L));
    var29.flip(0);
    BitSet var46 = var29.get(64, 100);
    BitSet var47 = new BitSet();
    boolean var49 = var47.get(0);
    int var50 = var47.length();
    BitSet var51 = new BitSet();
    boolean var53 = var51.get(0);
    var51.set(100, true);
    boolean var57 = var47.intersects(var51);
    boolean var59 = var47.equals((java.lang.Object)(-1L));
    BitSet var60 = new BitSet();
    boolean var62 = var60.get(0);
    int var63 = var60.length();
    BitSet var64 = new BitSet();
    boolean var66 = var64.get(0);
    var64.set(100, true);
    var64.set(0, true);
    var60.andNot(var64);
    var60.flip(64);
    var60.set(100, false);
    var47.xor(var60);
    boolean var80 = var29.intersects(var60);
    BitSet var81 = new BitSet();
    boolean var83 = var81.get(0);
    int var85 = var81.nextClearBit(0);
    var29.or(var81);
    boolean var87 = var18.equals((java.lang.Object)var81);
    var18.flip(100);
    boolean var90 = var18.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var28);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var46);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var80 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var83 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var87 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var90 == false);

  }

  public void test338() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test338");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    var0.clear(0, 0);
    java.lang.String var18 = var0.toString();
    var0.clear();
    BitSet var21 = new BitSet(54);
    var0.and(var21);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    var23.set(100, true);
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    int var32 = var29.length();
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    var33.set(100, true);
    boolean var39 = var29.intersects(var33);
    boolean var40 = var23.intersects(var33);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    int var44 = var41.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    boolean var51 = var41.intersects(var45);
    boolean var53 = var41.equals((java.lang.Object)(-1L));
    var41.flip(0);
    BitSet var58 = var41.get(64, 100);
    BitSet var59 = new BitSet();
    boolean var61 = var59.get(0);
    int var62 = var59.length();
    BitSet var63 = new BitSet();
    boolean var65 = var63.get(0);
    var63.set(100, true);
    boolean var69 = var59.intersects(var63);
    boolean var70 = var58.intersects(var63);
    var58.clear(64, 64);
    var33.andNot(var58);
    boolean var75 = var21.equals((java.lang.Object)var58);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var18 + "' != '" + "{0}"+ "'", var18.equals("{0}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var58);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == true);

  }

  public void test339() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test339");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    BitSet var16 = new BitSet(0);
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    int var26 = var23.length();
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    var27.set(100, true);
    boolean var33 = var23.intersects(var27);
    boolean var35 = var23.equals((java.lang.Object)(-1L));
    var17.or(var23);
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    BitSet var40 = new BitSet();
    var37.xor(var40);
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    BitSet var45 = new BitSet();
    var42.xor(var45);
    var37.and(var45);
    var45.flip(1);
    boolean var51 = var45.get(100);
    int var52 = var45.size();
    int var53 = var45.cardinality();
    var23.xor(var45);
    var23.flip(0, 128);
    var16.xor(var23);
    var0.xor(var23);
    var23.set(64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == 1);

  }

  public void test340() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test340");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    var0.flip(54, 64);
    boolean var24 = var0.get(10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);

  }

  public void test341() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test341");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    int var15 = var0.cardinality();
    boolean var16 = var0.isEmpty();
    var0.set(55);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == true);

  }

  public void test342() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test342");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var8.clear(64, 64);
    boolean var19 = var8.get(54);
    int var20 = var8.size();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      boolean var22 = var8.get((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 64);

  }

  public void test343() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test343");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    java.lang.Object var5 = var0.clone();
    int var6 = var0.length();
    int var7 = var0.cardinality();
    int var9 = var0.nextSetBit(0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var5);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 1);

  }

  public void test344() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test344");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var0.flip(54);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(101, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);

  }

  public void test345() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test345");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    int var5 = var3.length();
    var3.clear();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var3.set((-1), true);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);

  }

  public void test346() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test346");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var19 = var0.get(54);
    int var20 = var0.length();
    var0.clear(55);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(2, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 1);

  }

  public void test347() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test347");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var4 = var0.nextClearBit(0);
    java.lang.Object var5 = var0.clone();
    var0.flip(54);
    BitSet var9 = new BitSet(54);
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    BitSet var13 = new BitSet();
    var10.xor(var13);
    boolean var16 = var13.equals((java.lang.Object)(-1L));
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    int var20 = var17.length();
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    var21.set(100, true);
    boolean var27 = var17.intersects(var21);
    boolean var29 = var17.equals((java.lang.Object)(-1L));
    var17.flip(0);
    int var32 = var17.cardinality();
    boolean var33 = var13.intersects(var17);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    boolean var46 = var38.get(54);
    var38.set(64, true);
    int var51 = var38.nextSetBit(54);
    int var52 = var38.size();
    boolean var53 = var17.intersects(var38);
    var9.andNot(var38);
    var0.or(var9);
    boolean var56 = var0.isEmpty();
    var0.flip(65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var5);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);

  }

  public void test348() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test348");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.clear(1, 100);
    var0.andNot(var13);
    var0.flip(128, 128);
    int var27 = var0.nextClearBit(55);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    int var31 = var28.length();
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    var32.set(100, true);
    boolean var38 = var28.intersects(var32);
    boolean var40 = var28.equals((java.lang.Object)(-1L));
    var28.flip(0);
    BitSet var45 = var28.get(64, 100);
    boolean var47 = var28.get(54);
    int var48 = var28.length();
    var28.set(2, 10);
    boolean var53 = var28.get(100);
    var0.xor(var28);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(2, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 55);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var45);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);

  }

  public void test349() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test349");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var17 = var0.intersects(var10);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    var10.xor(var18);
    var10.set(1, true);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var10.clear(100, 65);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);

  }

  public void test350() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test350");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    java.lang.Object var5 = var0.clone();
    int var6 = var0.length();
    var0.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var5);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == 2);

  }

  public void test351() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test351");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var11 = var0.isEmpty();
    var0.set(10, 100);
    var0.flip(0);
    var0.set(0, true);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    boolean var26 = var23.equals((java.lang.Object)(-1L));
    int var27 = var23.length();
    java.lang.String var28 = var23.toString();
    boolean var29 = var0.equals((java.lang.Object)var23);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var28 + "' != '" + "{}"+ "'", var28.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);

  }

  public void test352() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test352");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    BitSet var15 = var0.get(1, 100);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    BitSet var24 = new BitSet();
    var21.xor(var24);
    var16.and(var24);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    boolean var38 = var16.intersects(var27);
    var0.xor(var16);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      int var41 = var16.nextClearBit((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);

  }

  public void test353() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test353");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    int var34 = var31.length();
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    var35.set(100, true);
    var35.set(0, true);
    var31.andNot(var35);
    var31.flip(64);
    var31.set(100, false);
    var18.xor(var31);
    boolean var51 = var0.intersects(var31);
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    int var56 = var52.nextClearBit(0);
    var0.or(var52);
    int var58 = var0.length();
    var0.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 1);

  }

  public void test354() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test354");


    BitSet var1 = new BitSet(90);
    int var2 = var1.length();
    var1.flip(10, 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == 0);

  }

  public void test355() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test355");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    var9.clear();
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    int var25 = var14.size();
    java.lang.Object var26 = var14.clone();
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    var27.set(100, true);
    var27.set(0, true);
    int var37 = var27.nextSetBit(64);
    BitSet var39 = new BitSet(10);
    var27.or(var39);
    boolean var41 = var14.intersects(var27);
    boolean var42 = var27.isEmpty();
    var9.or(var27);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var46 = var9.get(100, 2);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);

  }

  public void test356() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test356");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    int var5 = var0.length();
    int var6 = var0.cardinality();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(128, 127);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == 1);

  }

  public void test357() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test357");


    BitSet var1 = new BitSet(54);
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    BitSet var5 = new BitSet();
    var2.xor(var5);
    boolean var8 = var5.equals((java.lang.Object)(-1L));
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    int var24 = var9.cardinality();
    boolean var25 = var5.intersects(var9);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var29 = var26.length();
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    var30.set(100, true);
    boolean var36 = var26.intersects(var30);
    boolean var38 = var30.get(54);
    var30.set(64, true);
    int var43 = var30.nextSetBit(54);
    int var44 = var30.size();
    boolean var45 = var9.intersects(var30);
    var1.andNot(var30);
    boolean var47 = var1.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == true);

  }

  public void test358() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test358");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var24.equals((java.lang.Object)(-1L));
    var18.or(var24);
    boolean var38 = var0.intersects(var24);
    int var39 = var24.size();
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    int var43 = var40.length();
    BitSet var44 = new BitSet();
    boolean var46 = var44.get(0);
    var44.set(100, true);
    boolean var50 = var40.intersects(var44);
    boolean var52 = var40.equals((java.lang.Object)(-1L));
    var40.flip(0);
    BitSet var57 = var40.get(64, 100);
    BitSet var60 = var40.get(2, 128);
    BitSet var61 = new BitSet();
    boolean var63 = var61.get(0);
    BitSet var64 = new BitSet();
    var61.xor(var64);
    int var66 = var64.length();
    var64.clear();
    boolean var68 = var60.intersects(var64);
    boolean var69 = var24.equals((java.lang.Object)var68);
    int var71 = var24.nextSetBit(90);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var57);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var60);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == (-1));

  }

  public void test359() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test359");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    int var15 = var0.length();
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    BitSet var24 = new BitSet();
    var21.xor(var24);
    var16.and(var24);
    var24.set(1, 100);
    var0.and(var24);
    int var31 = var0.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == 64);

  }

  public void test360() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test360");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    int var14 = var0.size();
    java.lang.Object var15 = var0.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);

  }

  public void test361() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test361");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var19 = var0.get(54);
    var0.flip(1);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(65, 64);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);

  }

  public void test362() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test362");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.set(0, true);
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    BitSet var26 = var9.get(64, 100);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var38 = var26.intersects(var31);
    var0.andNot(var31);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set(90, 64);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);

  }

  public void test363() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test363");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.set(0, true);
    int var23 = var13.nextSetBit(64);
    BitSet var25 = new BitSet(10);
    var13.or(var25);
    boolean var27 = var0.intersects(var13);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    boolean var39 = var28.isEmpty();
    int var40 = var28.size();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    int var44 = var41.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    boolean var51 = var41.intersects(var45);
    boolean var52 = var41.isEmpty();
    var41.set(10, 100);
    var28.xor(var41);
    int var58 = var28.nextClearBit(10);
    boolean var59 = var13.intersects(var28);
    BitSet var60 = new BitSet();
    boolean var62 = var60.get(0);
    BitSet var63 = new BitSet();
    var60.xor(var63);
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    BitSet var68 = new BitSet();
    var65.xor(var68);
    var60.and(var68);
    var60.set(10);
    boolean var73 = var28.equals((java.lang.Object)var60);
    BitSet var76 = var28.get(10, 101);
    int var78 = var76.nextClearBit(90);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var76.flip((-1), 127);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var76);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var78 == 90);

  }

  public void test364() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test364");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    int var13 = var10.length();
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    var14.set(100, true);
    boolean var20 = var10.intersects(var14);
    int var21 = var14.cardinality();
    var9.andNot(var14);
    int var23 = var9.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 0);

  }

  public void test365() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test365");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    var0.clear(1);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var6.flip(0);
    BitSet var23 = var6.get(64, 100);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var35 = var23.intersects(var28);
    var23.clear(64, 64);
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    int var42 = var39.length();
    BitSet var43 = new BitSet();
    boolean var45 = var43.get(0);
    var43.set(100, true);
    boolean var49 = var39.intersects(var43);
    boolean var51 = var39.equals((java.lang.Object)(-1L));
    var23.or(var39);
    var0.andNot(var23);
    java.lang.Object var54 = var0.clone();
    var0.clear(65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var23);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var54);

  }

  public void test366() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test366");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    int var13 = var2.size();
    var0.or(var2);
    var0.clear();
    var0.clear();
    int var17 = var0.size();
    int var18 = var0.cardinality();
    var0.flip(128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);

  }

  public void test367() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test367");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    boolean var7 = var0.equals((java.lang.Object)'a');
    int var8 = var0.length();
    var0.set(64, true);
    int var13 = var0.nextClearBit(55);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == 101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 55);

  }

  public void test368() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test368");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    int var15 = var0.length();
    int var16 = var0.cardinality();
    var0.set(100, 128);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    int var23 = var20.length();
    var20.clear(1);
    int var27 = var20.nextSetBit(64);
    int var29 = var20.nextClearBit(64);
    var0.andNot(var20);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 64);

  }

  public void test369() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test369");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    boolean var14 = var8.get(100);
    int var15 = var8.size();
    int var16 = var8.cardinality();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    BitSet var20 = new BitSet();
    var17.xor(var20);
    boolean var23 = var20.equals((java.lang.Object)(-1L));
    BitSet var26 = var20.get(0, 1);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    int var38 = var31.cardinality();
    var26.andNot(var31);
    boolean var40 = var8.intersects(var31);
    var31.clear(55);
    int var43 = var31.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 101);

  }

  public void test370() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test370");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.set(64);
    boolean var27 = var3.get(128);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    var28.set(100, false);
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    BitSet var45 = new BitSet();
    var42.xor(var45);
    boolean var48 = var45.equals((java.lang.Object)(-1L));
    var28.andNot(var45);
    BitSet var50 = new BitSet();
    boolean var52 = var50.get(0);
    BitSet var53 = new BitSet();
    boolean var55 = var53.get(0);
    BitSet var56 = new BitSet();
    var53.xor(var56);
    boolean var59 = var56.equals((java.lang.Object)(-1L));
    BitSet var62 = var56.get(0, 1);
    var62.flip(10, 64);
    int var66 = var62.cardinality();
    var50.xor(var62);
    var28.xor(var62);
    var3.and(var28);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var3.clear(100, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var62);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == 54);

  }

  public void test371() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test371");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var20 = var0.get((-1), 100);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);

  }

  public void test372() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test372");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    int var13 = var9.cardinality();
    var9.set(101, false);
    int var17 = var9.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 64);

  }

  public void test373() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test373");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    var35.flip(1);
    boolean var41 = var35.get(100);
    int var43 = var35.nextSetBit(1);
    var20.xor(var35);
    var0.andNot(var35);
    var0.clear(10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 1);

  }

  public void test374() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test374");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    boolean var12 = var0.isEmpty();
    var0.set(65, true);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    var20.set(0, true);
    var16.andNot(var20);
    var16.set(64, false);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    int var36 = var33.length();
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    var37.set(100, true);
    boolean var43 = var33.intersects(var37);
    boolean var45 = var33.equals((java.lang.Object)(-1L));
    var33.flip(0);
    int var49 = var33.nextClearBit(0);
    var16.andNot(var33);
    int var51 = var33.cardinality();
    var0.or(var33);
    var0.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 1);

  }

  public void test375() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test375");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var17 = var0.intersects(var10);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    var18.flip(0);
    BitSet var35 = var18.get(64, 100);
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    int var39 = var36.length();
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    var40.set(100, true);
    boolean var46 = var36.intersects(var40);
    boolean var47 = var35.intersects(var40);
    var35.clear(64, 64);
    var10.andNot(var35);
    var35.flip(0, 128);
    java.lang.String var55 = var35.toString();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var35);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var55 + "' != '" + "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127}"+ "'", var55.equals("{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127}"));

  }

  public void test376() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test376");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    int var15 = var0.length();
    int var16 = var0.cardinality();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    BitSet var20 = new BitSet();
    var17.xor(var20);
    boolean var23 = var20.equals((java.lang.Object)(-1L));
    BitSet var26 = var20.get(0, 1);
    var20.clear();
    var0.andNot(var20);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);

  }

  public void test377() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test377");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    java.lang.String var28 = var21.toString();
    int var29 = var21.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var28 + "' != '" + "{1}"+ "'", var28.equals("{1}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 2);

  }

  public void test378() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test378");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var17 = var0.intersects(var10);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    var18.flip(0);
    BitSet var35 = var18.get(64, 100);
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    int var39 = var36.length();
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    var40.set(100, true);
    boolean var46 = var36.intersects(var40);
    boolean var47 = var35.intersects(var40);
    var35.clear(64, 64);
    var10.andNot(var35);
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    BitSet var55 = new BitSet();
    var52.xor(var55);
    boolean var58 = var55.equals((java.lang.Object)(-1L));
    BitSet var59 = new BitSet();
    boolean var61 = var59.get(0);
    BitSet var62 = new BitSet();
    var59.xor(var62);
    var55.and(var62);
    boolean var65 = var35.intersects(var55);
    java.lang.Object var66 = var55.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var35);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var66);

  }

  public void test379() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test379");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    int var34 = var31.length();
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    var35.set(100, true);
    var35.set(0, true);
    var31.andNot(var35);
    var31.flip(64);
    var31.set(100, false);
    var18.xor(var31);
    boolean var51 = var0.intersects(var31);
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    int var55 = var52.length();
    BitSet var56 = new BitSet();
    boolean var58 = var56.get(0);
    var56.set(100, true);
    var56.set(0, true);
    var52.andNot(var56);
    var52.set(64, false);
    BitSet var69 = new BitSet();
    boolean var71 = var69.get(0);
    int var72 = var69.length();
    BitSet var73 = new BitSet();
    boolean var75 = var73.get(0);
    var73.set(100, true);
    boolean var79 = var69.intersects(var73);
    boolean var81 = var69.equals((java.lang.Object)(-1L));
    var69.flip(0);
    int var85 = var69.nextClearBit(0);
    var52.andNot(var69);
    boolean var87 = var0.equals((java.lang.Object)var69);
    boolean var89 = var0.get(10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var79 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var81 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var87 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var89 == false);

  }

  public void test380() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test380");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    boolean var14 = var8.get(100);
    int var15 = var8.size();
    java.lang.Object var16 = var8.clone();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    int var23 = var17.size();
    var8.and(var17);
    java.lang.Object var25 = var17.clone();
    int var27 = var17.nextSetBit(0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var16);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var25);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 100);

  }

  public void test381() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test381");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    int var18 = var15.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    var19.set(100, true);
    boolean var25 = var15.intersects(var19);
    boolean var27 = var15.equals((java.lang.Object)(-1L));
    var15.flip(0);
    BitSet var32 = var15.get(64, 100);
    var0.or(var15);
    int var34 = var15.size();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var37 = var15.get((-1), 127);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var32);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 64);

  }

  public void test382() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test382");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    boolean var10 = var3.isEmpty();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    int var14 = var11.length();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    var15.set(100, true);
    boolean var21 = var11.intersects(var15);
    int var22 = var11.size();
    java.lang.Object var23 = var11.clone();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    var24.set(0, true);
    int var34 = var24.nextSetBit(64);
    BitSet var36 = new BitSet(10);
    var24.or(var36);
    boolean var38 = var11.intersects(var24);
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    BitSet var42 = new BitSet();
    var39.xor(var42);
    BitSet var44 = new BitSet();
    boolean var46 = var44.get(0);
    BitSet var47 = new BitSet();
    var44.xor(var47);
    var39.and(var47);
    boolean var50 = var39.isEmpty();
    int var51 = var39.size();
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    int var55 = var52.length();
    BitSet var56 = new BitSet();
    boolean var58 = var56.get(0);
    var56.set(100, true);
    boolean var62 = var52.intersects(var56);
    boolean var63 = var52.isEmpty();
    var52.set(10, 100);
    var39.xor(var52);
    int var69 = var39.nextClearBit(10);
    boolean var70 = var24.intersects(var39);
    BitSet var71 = new BitSet();
    boolean var73 = var71.get(0);
    BitSet var74 = new BitSet();
    var71.xor(var74);
    BitSet var76 = new BitSet();
    boolean var78 = var76.get(0);
    BitSet var79 = new BitSet();
    var76.xor(var79);
    var71.and(var79);
    var71.set(10);
    boolean var84 = var39.equals((java.lang.Object)var71);
    boolean var85 = var3.equals((java.lang.Object)var71);
    int var86 = var71.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var23);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var78 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var86 == 64);

  }

  public void test383() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test383");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    boolean var15 = var0.isEmpty();
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    BitSet var24 = new BitSet();
    var21.xor(var24);
    var16.and(var24);
    var24.flip(1);
    BitSet var29 = new BitSet();
    var24.or(var29);
    var24.clear(64, 64);
    boolean var35 = var24.get(54);
    var0.or(var24);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.flip((-1), 128);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);

  }

  public void test384() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test384");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    int var7 = var3.length();
    var3.set(64, false);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    int var14 = var11.length();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    var15.set(100, true);
    var15.set(0, true);
    var11.andNot(var15);
    var11.flip(64);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    BitSet var41 = new BitSet();
    var38.xor(var41);
    BitSet var43 = new BitSet();
    boolean var45 = var43.get(0);
    BitSet var46 = new BitSet();
    var43.xor(var46);
    var38.and(var46);
    var46.flip(1);
    boolean var52 = var46.get(100);
    int var54 = var46.nextSetBit(1);
    var31.xor(var46);
    var11.andNot(var46);
    java.lang.String var57 = var11.toString();
    BitSet var60 = var11.get(2, 101);
    var3.and(var60);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var57 + "' != '" + "{64}"+ "'", var57.equals("{64}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var60);

  }

  public void test385() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test385");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    var9.clear();
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    int var32 = var29.length();
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    var33.set(100, true);
    boolean var39 = var29.intersects(var33);
    boolean var41 = var29.equals((java.lang.Object)(-1L));
    var29.flip(0);
    BitSet var46 = var29.get(64, 100);
    BitSet var47 = new BitSet();
    boolean var49 = var47.get(0);
    int var50 = var47.length();
    BitSet var51 = new BitSet();
    boolean var53 = var51.get(0);
    var51.set(100, true);
    boolean var57 = var47.intersects(var51);
    boolean var58 = var46.intersects(var51);
    var46.clear(64, 64);
    BitSet var62 = new BitSet();
    boolean var64 = var62.get(0);
    int var65 = var62.length();
    BitSet var66 = new BitSet();
    boolean var68 = var66.get(0);
    var66.set(100, true);
    boolean var72 = var62.intersects(var66);
    boolean var74 = var62.equals((java.lang.Object)(-1L));
    var46.or(var62);
    boolean var76 = var9.equals((java.lang.Object)var62);
    boolean var78 = var9.get(54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var46);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var74 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var76 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var78 == false);

  }

  public void test386() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test386");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    int var35 = var32.length();
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    var36.set(100, true);
    boolean var42 = var32.intersects(var36);
    boolean var43 = var31.intersects(var36);
    boolean var44 = var0.equals((java.lang.Object)var31);
    BitSet var47 = var0.get(10, 64);
    java.lang.String var48 = var0.toString();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var47);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var48 + "' != '" + "{}"+ "'", var48.equals("{}"));

  }

  public void test387() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test387");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.flip(1, 1);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var39 = var27.equals((java.lang.Object)(-1L));
    BitSet var42 = var27.get(1, 100);
    var3.or(var27);
    int var45 = var3.nextSetBit(1);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    int var49 = var46.length();
    BitSet var50 = new BitSet();
    boolean var52 = var50.get(0);
    var50.set(100, true);
    boolean var56 = var46.intersects(var50);
    boolean var58 = var46.equals((java.lang.Object)(-1L));
    BitSet var61 = var46.get(1, 100);
    int var62 = var46.cardinality();
    BitSet var63 = new BitSet();
    boolean var65 = var63.get(0);
    BitSet var66 = new BitSet();
    var63.xor(var66);
    boolean var69 = var66.equals((java.lang.Object)(-1L));
    int var70 = var66.length();
    boolean var71 = var46.intersects(var66);
    var3.and(var46);
    var46.clear();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var46.set((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var42);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var61);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);

  }

  public void test388() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test388");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    int var15 = var0.cardinality();
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    var20.set(0, true);
    var16.andNot(var20);
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    BitSet var44 = new BitSet();
    var41.xor(var44);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    BitSet var49 = new BitSet();
    var46.xor(var49);
    var41.and(var49);
    var49.flip(1);
    boolean var55 = var49.get(100);
    int var57 = var49.nextSetBit(1);
    var34.xor(var49);
    boolean var59 = var20.intersects(var49);
    var0.or(var20);
    int var61 = var20.size();
    var20.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == 128);

  }

  public void test389() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test389");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    int var16 = var13.length();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    var17.set(0, true);
    var13.andNot(var17);
    var13.flip(64);
    var13.set(100, false);
    var0.xor(var13);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    int var36 = var33.length();
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    var37.set(100, true);
    boolean var43 = var33.intersects(var37);
    boolean var45 = var33.equals((java.lang.Object)(-1L));
    var33.flip(0);
    BitSet var50 = var33.get(64, 100);
    BitSet var51 = new BitSet();
    boolean var53 = var51.get(0);
    int var54 = var51.length();
    BitSet var55 = new BitSet();
    boolean var57 = var55.get(0);
    var55.set(100, true);
    boolean var61 = var51.intersects(var55);
    boolean var62 = var50.intersects(var55);
    var50.clear();
    var0.and(var50);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var50);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);

  }

  public void test390() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test390");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var4 = var0.nextClearBit(0);
    java.lang.Object var5 = var0.clone();
    var0.flip(54);
    BitSet var9 = new BitSet(54);
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    BitSet var13 = new BitSet();
    var10.xor(var13);
    boolean var16 = var13.equals((java.lang.Object)(-1L));
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    int var20 = var17.length();
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    var21.set(100, true);
    boolean var27 = var17.intersects(var21);
    boolean var29 = var17.equals((java.lang.Object)(-1L));
    var17.flip(0);
    int var32 = var17.cardinality();
    boolean var33 = var13.intersects(var17);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    boolean var46 = var38.get(54);
    var38.set(64, true);
    int var51 = var38.nextSetBit(54);
    int var52 = var38.size();
    boolean var53 = var17.intersects(var38);
    var9.andNot(var38);
    var0.or(var9);
    boolean var56 = var0.isEmpty();
    var0.set(54, false);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      int var61 = var0.nextSetBit((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var5);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);

  }

  public void test391() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test391");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    int var5 = var0.length();
    var0.set(1, 100);
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    BitSet var12 = new BitSet();
    var9.xor(var12);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    BitSet var17 = new BitSet();
    var14.xor(var17);
    var9.and(var17);
    var17.flip(1);
    BitSet var22 = new BitSet();
    var17.or(var22);
    var17.clear(64, 64);
    boolean var28 = var17.get(54);
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    var29.set(100, true);
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    int var38 = var35.length();
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    var39.set(100, true);
    boolean var45 = var35.intersects(var39);
    boolean var46 = var29.intersects(var39);
    BitSet var47 = new BitSet();
    boolean var49 = var47.get(0);
    int var50 = var47.length();
    BitSet var51 = new BitSet();
    boolean var53 = var51.get(0);
    var51.set(100, true);
    boolean var57 = var47.intersects(var51);
    boolean var59 = var47.equals((java.lang.Object)(-1L));
    var39.xor(var47);
    int var61 = var47.length();
    boolean var62 = var17.equals((java.lang.Object)var61);
    var17.set(55, 65);
    var0.andNot(var17);
    int var67 = var17.length();
    int var69 = var17.nextClearBit(1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == 65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == 2);

  }

  public void test392() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test392");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    int var15 = var0.length();
    int var16 = var0.cardinality();
    var0.set(100, 128);
    boolean var21 = var0.get(90);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);

  }

  public void test393() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test393");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    var20.and(var28);
    var28.flip(1);
    boolean var34 = var28.get(100);
    int var35 = var28.size();
    int var36 = var28.cardinality();
    var6.xor(var28);
    var28.set(2, 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 1);

  }

  public void test394() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test394");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    BitSet var16 = new BitSet();
    var13.xor(var16);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    var13.and(var21);
    var21.flip(1);
    int var26 = var21.cardinality();
    var9.xor(var21);
    java.lang.String var28 = var21.toString();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var31 = var21.get(128, 10);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var28 + "' != '" + "{1}"+ "'", var28.equals("{1}"));

  }

  public void test395() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test395");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.flip(1, 1);
    boolean var27 = var3.isEmpty();
    int var28 = var3.size();
    int var29 = var3.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 64);

  }

  public void test396() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test396");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    var0.clear(64);
    java.lang.Object var17 = var0.clone();
    boolean var19 = var0.get(127);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);

  }

  public void test397() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test397");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var7.clear(2);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    BitSet var29 = new BitSet();
    var26.xor(var29);
    boolean var32 = var29.equals((java.lang.Object)(-1L));
    BitSet var35 = var29.get(0, 1);
    var35.flip(10, 64);
    var35.clear();
    java.lang.String var40 = var35.toString();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    BitSet var44 = new BitSet();
    var41.xor(var44);
    boolean var47 = var44.equals((java.lang.Object)(-1L));
    BitSet var50 = var44.get(0, 1);
    var35.xor(var44);
    BitSet var54 = var44.get(0, 65);
    boolean var55 = var7.intersects(var54);
    var54.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var35);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var40 + "' != '" + "{}"+ "'", var40.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var50);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);

  }

  public void test398() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test398");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.clear(1, 100);
    var0.andNot(var13);
    var0.flip(128, 128);
    int var27 = var0.nextClearBit(55);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    int var31 = var28.length();
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    var32.set(100, true);
    boolean var38 = var28.intersects(var32);
    boolean var40 = var28.equals((java.lang.Object)(-1L));
    var28.flip(0);
    BitSet var45 = var28.get(64, 100);
    boolean var47 = var28.get(54);
    int var48 = var28.length();
    var28.set(2, 10);
    boolean var53 = var28.get(100);
    var0.xor(var28);
    BitSet var55 = new BitSet();
    boolean var57 = var55.get(0);
    int var58 = var55.length();
    BitSet var59 = new BitSet();
    boolean var61 = var59.get(0);
    var59.set(100, true);
    boolean var65 = var55.intersects(var59);
    boolean var67 = var55.equals((java.lang.Object)(-1L));
    var55.flip(0);
    BitSet var72 = var55.get(64, 100);
    boolean var74 = var55.get(54);
    var55.flip(1);
    java.lang.Object var77 = var55.clone();
    boolean var79 = var55.get(0);
    boolean var80 = var0.intersects(var55);
    boolean var81 = var55.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 55);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var45);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var72);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var74 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var77);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var79 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var80 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var81 == false);

  }

  public void test399() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test399");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    boolean var14 = var2.equals((java.lang.Object)(-1L));
    var2.flip(0);
    BitSet var19 = var2.get(64, 100);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    int var23 = var20.length();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    boolean var30 = var20.intersects(var24);
    boolean var31 = var19.intersects(var24);
    var0.and(var19);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    BitSet var41 = new BitSet();
    var38.xor(var41);
    var33.and(var41);
    int var44 = var33.cardinality();
    var33.clear();
    java.lang.String var46 = var33.toString();
    java.lang.String var47 = var33.toString();
    BitSet var48 = new BitSet();
    boolean var50 = var48.get(0);
    var48.set(100, true);
    BitSet var54 = new BitSet();
    boolean var56 = var54.get(0);
    int var57 = var54.length();
    BitSet var58 = new BitSet();
    boolean var60 = var58.get(0);
    var58.set(100, true);
    boolean var64 = var54.intersects(var58);
    boolean var66 = var54.equals((java.lang.Object)(-1L));
    var48.or(var54);
    BitSet var68 = new BitSet();
    boolean var70 = var68.get(0);
    BitSet var71 = new BitSet();
    var68.xor(var71);
    BitSet var73 = new BitSet();
    boolean var75 = var73.get(0);
    BitSet var76 = new BitSet();
    var73.xor(var76);
    var68.and(var76);
    var76.flip(1);
    boolean var82 = var76.get(100);
    int var83 = var76.size();
    int var84 = var76.cardinality();
    var54.xor(var76);
    java.lang.String var86 = var76.toString();
    boolean var87 = var33.equals((java.lang.Object)var76);
    int var88 = var76.length();
    boolean var89 = var76.isEmpty();
    var19.or(var76);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var19);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var46 + "' != '" + "{}"+ "'", var46.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var47 + "' != '" + "{}"+ "'", var47.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var82 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var83 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var86 + "' != '" + "{1}"+ "'", var86.equals("{1}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var87 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var88 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var89 == false);

  }

  public void test400() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test400");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.set(0, true);
    int var23 = var13.nextSetBit(64);
    BitSet var25 = new BitSet(10);
    var13.or(var25);
    boolean var27 = var0.intersects(var13);
    boolean var28 = var13.isEmpty();
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    BitSet var32 = new BitSet();
    var29.xor(var32);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    BitSet var37 = new BitSet();
    var34.xor(var37);
    var29.and(var37);
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    BitSet var43 = new BitSet();
    var40.xor(var43);
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    BitSet var48 = new BitSet();
    var45.xor(var48);
    var40.and(var48);
    boolean var51 = var29.intersects(var40);
    int var53 = var40.nextSetBit(100);
    boolean var54 = var13.equals((java.lang.Object)var53);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var57 = var13.get((-1), 10);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);

  }

  public void test401() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test401");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    java.lang.Object var5 = var0.clone();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    BitSet var21 = var6.get(1, 100);
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    BitSet var25 = new BitSet();
    var22.xor(var25);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    var22.and(var30);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    BitSet var41 = new BitSet();
    var38.xor(var41);
    var33.and(var41);
    boolean var44 = var22.intersects(var33);
    var6.xor(var22);
    var0.andNot(var6);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var5);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var21);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);

  }

  public void test402() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test402");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var8.clear(64, 64);
    boolean var19 = var8.get(54);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var29 = var26.length();
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    var30.set(100, true);
    boolean var36 = var26.intersects(var30);
    boolean var37 = var20.intersects(var30);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    int var41 = var38.length();
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    var42.set(100, true);
    boolean var48 = var38.intersects(var42);
    boolean var50 = var38.equals((java.lang.Object)(-1L));
    var30.xor(var38);
    int var52 = var38.length();
    boolean var53 = var8.equals((java.lang.Object)var52);
    var8.set(55, 65);
    var8.flip(0);
    java.lang.Object var59 = var8.clone();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var8.flip((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var59);

  }

  public void test403() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test403");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    var35.flip(1);
    boolean var41 = var35.get(100);
    int var43 = var35.nextSetBit(1);
    var20.xor(var35);
    var0.andNot(var35);
    int var46 = var0.length();
    var0.set(55);
    int var49 = var0.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == 65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 128);

  }

  public void test404() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test404");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var24.equals((java.lang.Object)(-1L));
    var18.or(var24);
    boolean var38 = var0.intersects(var24);
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    BitSet var42 = new BitSet();
    var39.xor(var42);
    boolean var45 = var42.equals((java.lang.Object)(-1L));
    BitSet var48 = var42.get(0, 1);
    var48.flip(10, 64);
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    BitSet var55 = new BitSet();
    var52.xor(var55);
    BitSet var57 = new BitSet();
    boolean var59 = var57.get(0);
    BitSet var60 = new BitSet();
    var57.xor(var60);
    var52.and(var60);
    var60.flip(1);
    int var65 = var60.cardinality();
    var48.xor(var60);
    var60.set(0, false);
    boolean var70 = var0.intersects(var60);
    int var71 = var60.cardinality();
    int var73 = var60.nextSetBit(54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var48);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == (-1));

  }

  public void test405() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test405");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(64, 100);
    var9.clear();
    var9.clear(127);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);

  }

  public void test406() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test406");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    var0.set(100, false);
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    BitSet var22 = new BitSet();
    var19.xor(var22);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    BitSet var27 = new BitSet();
    var24.xor(var27);
    var19.and(var27);
    int var30 = var19.cardinality();
    var19.clear();
    java.lang.String var32 = var19.toString();
    java.lang.String var33 = var19.toString();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    int var43 = var40.length();
    BitSet var44 = new BitSet();
    boolean var46 = var44.get(0);
    var44.set(100, true);
    boolean var50 = var40.intersects(var44);
    boolean var52 = var40.equals((java.lang.Object)(-1L));
    var34.or(var40);
    BitSet var54 = new BitSet();
    boolean var56 = var54.get(0);
    BitSet var57 = new BitSet();
    var54.xor(var57);
    BitSet var59 = new BitSet();
    boolean var61 = var59.get(0);
    BitSet var62 = new BitSet();
    var59.xor(var62);
    var54.and(var62);
    var62.flip(1);
    boolean var68 = var62.get(100);
    int var69 = var62.size();
    int var70 = var62.cardinality();
    var40.xor(var62);
    java.lang.String var72 = var62.toString();
    boolean var73 = var19.equals((java.lang.Object)var62);
    var0.and(var19);
    BitSet var77 = var19.get(0, 101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var32 + "' != '" + "{}"+ "'", var32.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var33 + "' != '" + "{}"+ "'", var33.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var72 + "' != '" + "{1}"+ "'", var72.equals("{1}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var77);

  }

  public void test407() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test407");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var8.size();
    var8.clear(55, 128);
    java.lang.String var15 = var8.toString();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var15 + "' != '" + "{}"+ "'", var15.equals("{}"));

  }

  public void test408() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test408");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var17 = var0.intersects(var10);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    var18.and(var26);
    var18.flip(54);
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    int var34 = var31.length();
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    var35.set(100, true);
    boolean var41 = var31.intersects(var35);
    int var42 = var31.size();
    var31.clear(64);
    int var45 = var31.length();
    var18.xor(var31);
    var10.or(var18);
    var10.set(55, 101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 0);

  }

  public void test409() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test409");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var0.set(100, false);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    BitSet var17 = new BitSet();
    var14.xor(var17);
    boolean var20 = var17.equals((java.lang.Object)(-1L));
    var0.andNot(var17);
    var17.clear();
    boolean var23 = var17.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == true);

  }

  public void test410() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test410");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    boolean var29 = var26.equals((java.lang.Object)(-1L));
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    boolean var42 = var30.equals((java.lang.Object)(-1L));
    var30.flip(0);
    int var45 = var30.cardinality();
    boolean var46 = var26.intersects(var30);
    var0.and(var30);
    int var49 = var0.nextSetBit(1);
    BitSet var50 = new BitSet();
    boolean var52 = var50.get(0);
    int var53 = var50.length();
    BitSet var54 = new BitSet();
    boolean var56 = var54.get(0);
    var54.set(100, true);
    boolean var60 = var50.intersects(var54);
    boolean var61 = var50.isEmpty();
    var50.set(10, 100);
    boolean var66 = var50.get(101);
    var50.flip(128);
    boolean var69 = var0.equals((java.lang.Object)var50);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == false);

  }

  public void test411() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test411");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    var0.clear(0, 0);
    java.lang.String var18 = var0.toString();
    var0.clear();
    var0.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var18 + "' != '" + "{0}"+ "'", var18.equals("{0}"));

  }

  public void test412() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test412");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var4.cardinality();
    boolean var13 = var4.equals((java.lang.Object)1.0d);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    var32.set(100, true);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    int var41 = var38.length();
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    var42.set(100, true);
    boolean var48 = var38.intersects(var42);
    boolean var50 = var38.equals((java.lang.Object)(-1L));
    var32.or(var38);
    boolean var52 = var14.intersects(var38);
    int var53 = var38.size();
    var4.xor(var38);
    var38.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == 64);

  }

  public void test413() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test413");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.set(64, false);
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    int var20 = var17.length();
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    var21.set(100, true);
    boolean var27 = var17.intersects(var21);
    boolean var29 = var17.equals((java.lang.Object)(-1L));
    var17.flip(0);
    int var33 = var17.nextClearBit(0);
    var0.andNot(var17);
    int var35 = var17.cardinality();
    boolean var36 = var17.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);

  }

  public void test414() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test414");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    boolean var14 = var0.get(64);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    boolean var21 = var18.equals((java.lang.Object)(-1L));
    BitSet var24 = var18.get(0, 1);
    var24.flip(10, 64);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    var36.flip(1);
    int var41 = var36.cardinality();
    var24.xor(var36);
    var24.clear(101);
    var0.and(var24);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var24.set(64, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 1);

  }

  public void test415() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test415");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.flip(1, 1);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var39 = var27.equals((java.lang.Object)(-1L));
    BitSet var42 = var27.get(1, 100);
    var3.or(var27);
    int var45 = var3.nextSetBit(1);
    java.lang.Object var46 = var3.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var42);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var46);

  }

  public void test416() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test416");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var8.size();
    var8.clear(55, 128);
    int var15 = var8.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);

  }

  public void test417() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test417");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var0.set(100, false);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    BitSet var17 = new BitSet();
    var14.xor(var17);
    boolean var20 = var17.equals((java.lang.Object)(-1L));
    var0.andNot(var17);
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    boolean var31 = var28.equals((java.lang.Object)(-1L));
    BitSet var34 = var28.get(0, 1);
    var34.flip(10, 64);
    int var38 = var34.cardinality();
    var22.xor(var34);
    var0.xor(var34);
    int var41 = var0.size();
    boolean var43 = var0.get(128);
    int var45 = var0.nextClearBit(128);
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    int var49 = var46.length();
    BitSet var50 = new BitSet();
    boolean var52 = var50.get(0);
    var50.set(100, true);
    boolean var56 = var46.intersects(var50);
    BitSet var57 = new BitSet();
    boolean var59 = var57.get(0);
    BitSet var60 = new BitSet();
    var57.xor(var60);
    BitSet var62 = new BitSet();
    boolean var64 = var62.get(0);
    BitSet var65 = new BitSet();
    var62.xor(var65);
    var57.and(var65);
    var65.flip(1);
    boolean var71 = var65.get(100);
    int var73 = var65.nextSetBit(1);
    var50.xor(var65);
    var50.flip(100);
    var0.andNot(var50);
    int var78 = var50.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var34);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == 54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var78 == 2);

  }

  public void test418() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test418");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    var8.clear(0, 101);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    BitSet var24 = new BitSet();
    var21.xor(var24);
    var16.and(var24);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    boolean var38 = var16.intersects(var27);
    var8.or(var27);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var27.clear(128, 90);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);

  }

  public void test419() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test419");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    var35.flip(1);
    boolean var41 = var35.get(100);
    int var43 = var35.nextSetBit(1);
    var20.xor(var35);
    var0.andNot(var35);
    java.lang.String var46 = var0.toString();
    BitSet var49 = var0.get(2, 101);
    int var50 = var0.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var46 + "' != '" + "{64}"+ "'", var46.equals("{64}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var49);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == 65);

  }

  public void test420() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test420");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var3.clear();
    var3.clear(1);
    var3.flip(65, 128);
    var3.flip(90);
    var3.clear(64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);

  }

  public void test421() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test421");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    java.lang.Object var5 = var0.clone();
    var0.set(65, 65, true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var5);

  }

  public void test422() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test422");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    int var18 = var15.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    var19.set(100, true);
    boolean var25 = var15.intersects(var19);
    boolean var27 = var15.equals((java.lang.Object)(-1L));
    var15.flip(0);
    BitSet var32 = var15.get(64, 100);
    var0.or(var15);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    int var45 = var38.cardinality();
    var0.xor(var38);
    int var47 = var0.length();
    BitSet var48 = new BitSet();
    boolean var50 = var48.get(0);
    BitSet var51 = new BitSet();
    var48.xor(var51);
    boolean var54 = var51.equals((java.lang.Object)(-1L));
    BitSet var57 = var51.get(0, 1);
    var57.flip(10, 64);
    BitSet var61 = new BitSet();
    boolean var63 = var61.get(0);
    BitSet var64 = new BitSet();
    var61.xor(var64);
    BitSet var66 = new BitSet();
    boolean var68 = var66.get(0);
    BitSet var69 = new BitSet();
    var66.xor(var69);
    var61.and(var69);
    var69.flip(1);
    int var74 = var69.cardinality();
    var57.xor(var69);
    int var76 = var57.length();
    var0.or(var57);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var32);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == 101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var57);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var74 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var76 == 64);

  }

  public void test423() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test423");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    int var12 = var0.size();
    var0.set(0, true);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    int var19 = var16.length();
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    boolean var26 = var16.intersects(var20);
    int var27 = var16.size();
    var16.clear(64);
    int var30 = var16.length();
    var0.xor(var16);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);

  }

  public void test424() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test424");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    boolean var14 = var8.get(100);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    var15.flip(1);
    int var20 = var15.length();
    var15.set(1, 100);
    var8.or(var15);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var15.set(101, 0);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 2);

  }

  public void test425() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test425");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    int var16 = var0.nextClearBit(100);
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    int var23 = var20.length();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    var24.set(0, true);
    var20.andNot(var24);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    int var37 = var34.length();
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    boolean var44 = var34.intersects(var38);
    boolean var46 = var34.equals((java.lang.Object)(-1L));
    var34.flip(0);
    BitSet var51 = var34.get(64, 100);
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    int var55 = var52.length();
    BitSet var56 = new BitSet();
    boolean var58 = var56.get(0);
    var56.set(100, true);
    boolean var62 = var52.intersects(var56);
    boolean var63 = var51.intersects(var56);
    boolean var64 = var20.equals((java.lang.Object)var51);
    int var66 = var20.nextSetBit(128);
    var17.or(var20);
    int var69 = var20.nextSetBit(0);
    var0.andNot(var20);
    var0.clear(101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var51);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == (-1));

  }

  public void test426() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test426");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    boolean var14 = var2.equals((java.lang.Object)(-1L));
    var2.flip(0);
    BitSet var19 = var2.get(64, 100);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    int var23 = var20.length();
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    var24.set(100, true);
    boolean var30 = var20.intersects(var24);
    boolean var31 = var19.intersects(var24);
    var0.and(var19);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    var33.set(100, true);
    var33.clear(1, 100);
    int var43 = var33.nextSetBit(1);
    int var45 = var33.nextClearBit(1);
    var0.xor(var33);
    var0.set(90);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var19);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);

  }

  public void test427() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test427");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear(100);
    boolean var15 = var0.get(101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);

  }

  public void test428() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test428");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    java.lang.String var13 = var0.toString();
    java.lang.String var14 = var0.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    int var18 = var15.length();
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    var19.set(100, true);
    boolean var25 = var15.intersects(var19);
    boolean var27 = var15.equals((java.lang.Object)(-1L));
    var15.flip(0);
    BitSet var32 = var15.get(64, 100);
    var0.or(var15);
    var0.flip(90, 101);
    boolean var37 = var0.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var13 + "' != '" + "{}"+ "'", var13.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var32);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);

  }

  public void test429() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test429");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    int var35 = var32.length();
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    var36.set(100, true);
    boolean var42 = var32.intersects(var36);
    boolean var43 = var31.intersects(var36);
    boolean var44 = var0.equals((java.lang.Object)var31);
    var31.flip(54, 127);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == true);

  }

  public void test430() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test430");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var19 = var0.get(54);
    var0.flip(1);
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.flip(1);
    int var27 = var22.length();
    var22.set(1, 100);
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    int var34 = var31.length();
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    var35.set(100, true);
    boolean var41 = var31.intersects(var35);
    boolean var43 = var31.equals((java.lang.Object)(-1L));
    var31.flip(0);
    var31.clear(0, 0);
    var22.and(var31);
    var0.xor(var31);
    int var52 = var31.nextClearBit(2);
    var31.clear(10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 2);

  }

  public void test431() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test431");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    boolean var29 = var26.equals((java.lang.Object)(-1L));
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    boolean var42 = var30.equals((java.lang.Object)(-1L));
    var30.flip(0);
    int var45 = var30.cardinality();
    boolean var46 = var26.intersects(var30);
    var0.and(var30);
    java.lang.String var48 = var0.toString();
    BitSet var49 = new BitSet();
    boolean var51 = var49.get(0);
    int var52 = var49.length();
    BitSet var53 = new BitSet();
    boolean var55 = var53.get(0);
    var53.set(100, true);
    boolean var59 = var49.intersects(var53);
    boolean var60 = var49.isEmpty();
    var49.set(10, 100);
    var0.or(var49);
    boolean var65 = var49.isEmpty();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var48 + "' != '" + "{}"+ "'", var48.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);

  }

  public void test432() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test432");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    int var5 = var0.length();
    var0.set(1, 100);
    BitSet var9 = new BitSet();
    boolean var11 = var9.get(0);
    int var12 = var9.length();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    boolean var19 = var9.intersects(var13);
    boolean var21 = var9.equals((java.lang.Object)(-1L));
    var9.flip(0);
    var9.clear(0, 0);
    var0.and(var9);
    var9.set(54, false);
    boolean var32 = var9.get(65);
    var9.set(128);
    var9.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);

  }

  public void test433() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test433");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var0.set(100, false);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    BitSet var17 = new BitSet();
    var14.xor(var17);
    boolean var20 = var17.equals((java.lang.Object)(-1L));
    var0.andNot(var17);
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    boolean var31 = var28.equals((java.lang.Object)(-1L));
    BitSet var34 = var28.get(0, 1);
    var34.flip(10, 64);
    int var38 = var34.cardinality();
    var22.xor(var34);
    var0.xor(var34);
    int var41 = var0.size();
    boolean var43 = var0.get(128);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set((-1), false);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var34);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == 54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);

  }

  public void test434() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test434");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    int var24 = var3.size();
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    var25.set(100, true);
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    int var34 = var31.length();
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    var35.set(100, true);
    boolean var41 = var31.intersects(var35);
    boolean var43 = var31.equals((java.lang.Object)(-1L));
    var25.or(var31);
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    BitSet var48 = new BitSet();
    var45.xor(var48);
    BitSet var50 = new BitSet();
    boolean var52 = var50.get(0);
    BitSet var53 = new BitSet();
    var50.xor(var53);
    var45.and(var53);
    var53.flip(1);
    boolean var59 = var53.get(100);
    int var60 = var53.size();
    int var61 = var53.cardinality();
    var31.xor(var53);
    var31.flip(0, 128);
    boolean var66 = var31.isEmpty();
    var3.or(var31);
    BitSet var68 = new BitSet();
    boolean var70 = var68.get(0);
    BitSet var71 = new BitSet();
    var68.xor(var71);
    BitSet var73 = new BitSet();
    boolean var75 = var73.get(0);
    BitSet var76 = new BitSet();
    var73.xor(var76);
    var68.and(var76);
    int var79 = var68.cardinality();
    var68.clear();
    java.lang.String var81 = var68.toString();
    java.lang.String var82 = var68.toString();
    int var84 = var68.nextClearBit(100);
    boolean var85 = var31.intersects(var68);
    var68.set(0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var79 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var81 + "' != '" + "{}"+ "'", var81.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var82 + "' != '" + "{}"+ "'", var82.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == false);

  }

  public void test435() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test435");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    var9.clear();
    java.lang.String var14 = var9.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    boolean var21 = var18.equals((java.lang.Object)(-1L));
    BitSet var24 = var18.get(0, 1);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    int var28 = var25.length();
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    var29.set(100, true);
    boolean var35 = var25.intersects(var29);
    int var36 = var29.cardinality();
    var24.andNot(var29);
    int var39 = var29.nextSetBit(0);
    var9.xor(var29);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var29.set(64, 54);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == 100);

  }

  public void test436() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test436");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    int var13 = var9.cardinality();
    var9.set(101, false);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var9.set(64, 55);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 54);

  }

  public void test437() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test437");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      int var3 = var0.nextSetBit((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);

  }

  public void test438() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test438");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var24.equals((java.lang.Object)(-1L));
    var18.or(var24);
    boolean var38 = var0.intersects(var24);
    var24.set(2, 128, true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);

  }

  public void test439() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test439");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var4.cardinality();
    boolean var13 = var4.equals((java.lang.Object)1.0d);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    var32.set(100, true);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    int var41 = var38.length();
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    var42.set(100, true);
    boolean var48 = var38.intersects(var42);
    boolean var50 = var38.equals((java.lang.Object)(-1L));
    var32.or(var38);
    boolean var52 = var14.intersects(var38);
    int var53 = var38.size();
    var4.xor(var38);
    int var56 = var38.nextSetBit(2);
    var38.clear(55);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == (-1));

  }

  public void test440() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test440");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    var9.clear();
    java.lang.String var14 = var9.toString();
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    boolean var21 = var18.equals((java.lang.Object)(-1L));
    BitSet var24 = var18.get(0, 1);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    int var28 = var25.length();
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    var29.set(100, true);
    boolean var35 = var25.intersects(var29);
    int var36 = var29.cardinality();
    var24.andNot(var29);
    int var39 = var29.nextSetBit(0);
    var9.xor(var29);
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    var41.set(100, true);
    BitSet var47 = new BitSet();
    boolean var49 = var47.get(0);
    int var50 = var47.length();
    BitSet var51 = new BitSet();
    boolean var53 = var51.get(0);
    var51.set(100, true);
    boolean var57 = var47.intersects(var51);
    boolean var59 = var47.equals((java.lang.Object)(-1L));
    var41.or(var47);
    BitSet var61 = new BitSet();
    boolean var63 = var61.get(0);
    BitSet var64 = new BitSet();
    var61.xor(var64);
    BitSet var66 = new BitSet();
    boolean var68 = var66.get(0);
    BitSet var69 = new BitSet();
    var66.xor(var69);
    var61.and(var69);
    var69.flip(1);
    boolean var75 = var69.get(100);
    int var76 = var69.size();
    int var77 = var69.cardinality();
    var47.xor(var69);
    int var79 = var47.cardinality();
    var9.xor(var47);
    int var81 = var9.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var76 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var77 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var79 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var81 == 101);

  }

  public void test441() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test441");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.set(64, false);
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    int var20 = var17.length();
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    var21.set(100, true);
    boolean var27 = var17.intersects(var21);
    boolean var29 = var17.equals((java.lang.Object)(-1L));
    var17.flip(0);
    int var33 = var17.nextClearBit(0);
    var0.andNot(var17);
    var17.set(90);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 1);

  }

  public void test442() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test442");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(54, 64, true);
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    BitSet var25 = new BitSet();
    var22.xor(var25);
    boolean var28 = var25.equals((java.lang.Object)(-1L));
    BitSet var31 = var25.get(0, 1);
    var31.flip(64, 100);
    var31.flip(0);
    boolean var37 = var7.intersects(var31);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    var38.set(100, true);
    var38.set(0, true);
    var38.set(0, true);
    var31.andNot(var38);
    var0.or(var31);
    int var52 = var31.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 36);

  }

  public void test443() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test443");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    var0.clear(64);
    int var14 = var0.length();
    int var15 = var0.cardinality();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(90, 0);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);

  }

  public void test444() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test444");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.set(1, 100);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    boolean var33 = var14.get(54);
    var8.and(var14);
    var14.flip(90);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);

  }

  public void test445() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test445");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    int var13 = var2.size();
    var0.or(var2);
    var0.clear();
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    boolean var22 = var19.equals((java.lang.Object)(-1L));
    BitSet var25 = var19.get(0, 1);
    var25.flip(10, 64);
    var25.clear();
    java.lang.String var30 = var25.toString();
    var25.clear(100);
    var0.andNot(var25);
    var25.set(90, 90);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var25);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var30 + "' != '" + "{}"+ "'", var30.equals("{}"));

  }

  public void test446() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test446");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    BitSet var15 = var0.get(1, 100);
    int var16 = var0.cardinality();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    BitSet var20 = new BitSet();
    var17.xor(var20);
    boolean var23 = var20.equals((java.lang.Object)(-1L));
    int var24 = var20.length();
    boolean var25 = var0.intersects(var20);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    var26.set(101);
    var0.and(var26);
    int var33 = var26.nextClearBit(10);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 10);

  }

  public void test447() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test447");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var4.cardinality();
    boolean var13 = var4.equals((java.lang.Object)1.0d);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    var32.set(100, true);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    int var41 = var38.length();
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    var42.set(100, true);
    boolean var48 = var38.intersects(var42);
    boolean var50 = var38.equals((java.lang.Object)(-1L));
    var32.or(var38);
    boolean var52 = var14.intersects(var38);
    int var53 = var38.size();
    var4.xor(var38);
    BitSet var55 = new BitSet();
    boolean var57 = var55.get(0);
    int var58 = var55.length();
    BitSet var59 = new BitSet();
    boolean var61 = var59.get(0);
    var59.set(100, true);
    boolean var65 = var55.intersects(var59);
    boolean var67 = var59.get(54);
    var59.set(64, true);
    int var72 = var59.nextSetBit(54);
    var38.xor(var59);
    var38.set(10, false);
    var38.clear(0, 65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == 64);

  }

  public void test448() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test448");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var4 = var0.nextClearBit(0);
    var0.flip(101, 101);
    int var8 = var0.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == 64);

  }

  public void test449() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test449");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    var9.clear();
    java.lang.String var14 = var9.toString();
    var9.clear(100);
    var9.clear(2, 100);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    boolean var26 = var23.equals((java.lang.Object)(-1L));
    BitSet var29 = var23.get(0, 1);
    var29.flip(10, 64);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    BitSet var41 = new BitSet();
    var38.xor(var41);
    var33.and(var41);
    var41.flip(1);
    int var46 = var41.cardinality();
    var29.xor(var41);
    java.lang.String var48 = var41.toString();
    var41.clear(1);
    var9.xor(var41);
    boolean var53 = var9.equals((java.lang.Object)(short)0);
    var9.clear(36);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var29);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var48 + "' != '" + "{1}"+ "'", var48.equals("{1}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);

  }

  public void test450() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test450");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    var9.clear();
    java.lang.String var14 = var9.toString();
    var9.clear(100);
    var9.clear(2, 100);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    BitSet var23 = new BitSet();
    var20.xor(var23);
    boolean var26 = var23.equals((java.lang.Object)(-1L));
    BitSet var29 = var23.get(0, 1);
    var29.flip(10, 64);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    BitSet var41 = new BitSet();
    var38.xor(var41);
    var33.and(var41);
    var41.flip(1);
    int var46 = var41.cardinality();
    var29.xor(var41);
    java.lang.String var48 = var41.toString();
    var41.clear(1);
    var9.xor(var41);
    var41.set(0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var29);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var48 + "' != '" + "{1}"+ "'", var48.equals("{1}"));

  }

  public void test451() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test451");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var17 = var0.intersects(var10);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    boolean var24 = var21.equals((java.lang.Object)(-1L));
    BitSet var27 = var21.get(0, 1);
    var27.flip(10, 64);
    var27.clear();
    java.lang.String var32 = var27.toString();
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    boolean var39 = var36.equals((java.lang.Object)(-1L));
    BitSet var42 = var36.get(0, 1);
    var27.xor(var36);
    var10.andNot(var36);
    var36.clear();
    boolean var47 = var36.get(36);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var27);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var32 + "' != '" + "{}"+ "'", var32.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var42);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);

  }

  public void test452() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test452");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    boolean var5 = var3.get(0);
    int var6 = var3.length();
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    var7.set(100, true);
    var7.set(0, true);
    var3.andNot(var7);
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    int var20 = var17.length();
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    var21.set(100, true);
    boolean var27 = var17.intersects(var21);
    boolean var29 = var17.equals((java.lang.Object)(-1L));
    var17.flip(0);
    BitSet var34 = var17.get(64, 100);
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    int var38 = var35.length();
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    var39.set(100, true);
    boolean var45 = var35.intersects(var39);
    boolean var46 = var34.intersects(var39);
    boolean var47 = var3.equals((java.lang.Object)var34);
    int var49 = var3.nextSetBit(128);
    var0.or(var3);
    int var52 = var3.nextSetBit(0);
    BitSet var53 = new BitSet();
    boolean var55 = var53.get(0);
    int var56 = var53.length();
    BitSet var57 = new BitSet();
    boolean var59 = var57.get(0);
    var57.set(100, true);
    boolean var63 = var53.intersects(var57);
    int var64 = var53.size();
    var53.clear(64);
    int var67 = var53.length();
    int var68 = var53.length();
    var3.xor(var53);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var3.flip(1, (-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var34);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == 0);

  }

  public void test453() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test453");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.set(1, 100);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var8.set(128, 36);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);

  }

  public void test454() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test454");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.set(100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);

  }

  public void test455() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test455");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var19 = var0.get(54);
    int var20 = var0.length();
    var0.set(2, 10);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    BitSet var27 = new BitSet();
    var24.xor(var27);
    boolean var30 = var27.equals((java.lang.Object)(-1L));
    BitSet var33 = var27.get(0, 1);
    var33.flip(10, 64);
    var33.clear();
    java.lang.String var38 = var33.toString();
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    BitSet var42 = new BitSet();
    var39.xor(var42);
    boolean var45 = var42.equals((java.lang.Object)(-1L));
    BitSet var48 = var42.get(0, 1);
    var33.xor(var42);
    int var51 = var33.nextSetBit(10);
    var0.andNot(var33);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.set((-1));
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var33);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var38 + "' != '" + "{}"+ "'", var38.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var48);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == (-1));

  }

  public void test456() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test456");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.flip(1);
    int var5 = var0.length();
    var0.set(1, 100);
    var0.clear(100);
    int var11 = var0.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 128);

  }

  public void test457() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test457");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var17 = var0.intersects(var10);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    BitSet var21 = new BitSet();
    var18.xor(var21);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    var18.and(var26);
    var18.flip(54);
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    int var34 = var31.length();
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    var35.set(100, true);
    boolean var41 = var31.intersects(var35);
    int var42 = var31.size();
    var31.clear(64);
    int var45 = var31.length();
    var18.xor(var31);
    var10.or(var18);
    var18.clear(55);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 0);

  }

  public void test458() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test458");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    var0.flip(54, 64);
    int var24 = var0.nextSetBit(65);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    BitSet var33 = new BitSet();
    var30.xor(var33);
    var25.and(var33);
    var33.set(1, 100);
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    int var42 = var39.length();
    BitSet var43 = new BitSet();
    boolean var45 = var43.get(0);
    var43.set(100, true);
    boolean var49 = var39.intersects(var43);
    boolean var51 = var39.equals((java.lang.Object)(-1L));
    var39.flip(0);
    BitSet var56 = var39.get(64, 100);
    boolean var58 = var39.get(54);
    var33.and(var39);
    BitSet var60 = new BitSet();
    int var61 = var60.length();
    BitSet var62 = new BitSet();
    boolean var64 = var62.get(0);
    int var65 = var62.length();
    BitSet var66 = new BitSet();
    boolean var68 = var66.get(0);
    var66.set(100, true);
    boolean var72 = var62.intersects(var66);
    boolean var74 = var62.equals((java.lang.Object)(-1L));
    var62.flip(0);
    BitSet var79 = var62.get(64, 100);
    BitSet var80 = new BitSet();
    boolean var82 = var80.get(0);
    int var83 = var80.length();
    BitSet var84 = new BitSet();
    boolean var86 = var84.get(0);
    var84.set(100, true);
    boolean var90 = var80.intersects(var84);
    boolean var91 = var79.intersects(var84);
    var60.and(var79);
    java.lang.String var93 = var60.toString();
    boolean var94 = var39.equals((java.lang.Object)var93);
    BitSet var97 = var39.get(0, 54);
    boolean var98 = var0.intersects(var39);
    int var99 = var39.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var56);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var74 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var79);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var82 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var83 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var86 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var90 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var91 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var93 + "' != '" + "{}"+ "'", var93.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var94 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var97);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var98 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var99 == 1);

  }

  public void test459() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test459");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    boolean var29 = var26.equals((java.lang.Object)(-1L));
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    boolean var42 = var30.equals((java.lang.Object)(-1L));
    var30.flip(0);
    int var45 = var30.cardinality();
    boolean var46 = var26.intersects(var30);
    var0.and(var30);
    java.lang.String var48 = var0.toString();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.flip(54, 0);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var48 + "' != '" + "{}"+ "'", var48.equals("{}"));

  }

  public void test460() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test460");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var8.clear(64, 64);
    boolean var19 = var8.get(54);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var29 = var26.length();
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    var30.set(100, true);
    boolean var36 = var26.intersects(var30);
    boolean var37 = var20.intersects(var30);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    int var41 = var38.length();
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    var42.set(100, true);
    boolean var48 = var38.intersects(var42);
    boolean var50 = var38.equals((java.lang.Object)(-1L));
    var30.xor(var38);
    int var52 = var38.length();
    boolean var53 = var8.equals((java.lang.Object)var52);
    var8.set(55, 65);
    var8.flip(0);
    boolean var60 = var8.get(90);
    BitSet var62 = new BitSet(54);
    boolean var63 = var62.isEmpty();
    var8.andNot(var62);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == true);

  }

  public void test461() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test461");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var28.get(54);
    var28.set(64, true);
    int var41 = var28.nextSetBit(54);
    int var42 = var28.size();
    boolean var43 = var7.intersects(var28);
    BitSet var44 = new BitSet();
    boolean var46 = var44.get(0);
    int var47 = var44.length();
    BitSet var48 = new BitSet();
    boolean var50 = var48.get(0);
    var48.set(100, true);
    boolean var54 = var44.intersects(var48);
    var44.set(0, 1);
    var28.andNot(var44);
    var44.set(36, true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);

  }

  public void test462() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test462");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var11 = var0.isEmpty();
    var0.set(10, 100);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    var15.flip(1);
    java.lang.Object var20 = var15.clone();
    int var22 = var15.nextSetBit(10);
    var0.xor(var15);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var20);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == (-1));

  }

  public void test463() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test463");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var8.clear(64, 64);
    boolean var19 = var8.get(54);
    BitSet var20 = new BitSet();
    boolean var22 = var20.get(0);
    var20.set(100, true);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var29 = var26.length();
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    var30.set(100, true);
    boolean var36 = var26.intersects(var30);
    boolean var37 = var20.intersects(var30);
    BitSet var38 = new BitSet();
    boolean var40 = var38.get(0);
    int var41 = var38.length();
    BitSet var42 = new BitSet();
    boolean var44 = var42.get(0);
    var42.set(100, true);
    boolean var48 = var38.intersects(var42);
    boolean var50 = var38.equals((java.lang.Object)(-1L));
    var30.xor(var38);
    int var52 = var38.length();
    boolean var53 = var8.equals((java.lang.Object)var52);
    var8.set(55, 65);
    var8.flip(0);
    boolean var60 = var8.get(90);
    int var61 = var8.size();
    BitSet var62 = new BitSet();
    boolean var64 = var62.get(0);
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    BitSet var68 = new BitSet();
    var65.xor(var68);
    boolean var71 = var68.equals((java.lang.Object)(-1L));
    BitSet var74 = var68.get(0, 1);
    var74.flip(10, 64);
    int var78 = var74.cardinality();
    var62.xor(var74);
    var62.set(54, false);
    boolean var83 = var8.equals((java.lang.Object)54);
    var8.set(127, true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var74);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var78 == 54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var83 == false);

  }

  public void test464() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test464");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var15 = new BitSet();
    boolean var17 = var15.get(0);
    BitSet var18 = new BitSet();
    var15.xor(var18);
    boolean var21 = var18.equals((java.lang.Object)(-1L));
    BitSet var24 = var18.get(0, 1);
    var24.flip(64, 100);
    var24.flip(0);
    boolean var30 = var0.intersects(var24);
    var24.set(127, true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var24);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == true);

  }

  public void test465() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test465");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var29 = var17.intersects(var22);
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    boolean var42 = var30.equals((java.lang.Object)(-1L));
    var30.flip(0);
    int var45 = var30.length();
    boolean var46 = var17.equals((java.lang.Object)var30);
    int var47 = var30.length();
    int var49 = var30.nextClearBit(36);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 36);

  }

  public void test466() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test466");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    boolean var19 = var0.get(54);
    int var20 = var0.length();
    int var21 = var0.size();
    int var22 = var0.length();
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    int var26 = var23.length();
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    var27.set(100, true);
    var27.set(0, true);
    var23.andNot(var27);
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    int var40 = var37.length();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    var41.set(100, true);
    boolean var47 = var37.intersects(var41);
    boolean var49 = var37.equals((java.lang.Object)(-1L));
    var37.flip(0);
    BitSet var54 = var37.get(64, 100);
    BitSet var55 = new BitSet();
    boolean var57 = var55.get(0);
    int var58 = var55.length();
    BitSet var59 = new BitSet();
    boolean var61 = var59.get(0);
    var59.set(100, true);
    boolean var65 = var55.intersects(var59);
    boolean var66 = var54.intersects(var59);
    boolean var67 = var23.equals((java.lang.Object)var54);
    BitSet var70 = var23.get(10, 64);
    boolean var71 = var0.equals((java.lang.Object)64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var70);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == false);

  }

  public void test467() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test467");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    BitSet var26 = var7.get(2, 128);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var39 = var27.equals((java.lang.Object)(-1L));
    var27.flip(0);
    var27.clear(0, 0);
    java.lang.String var45 = var27.toString();
    var27.clear();
    var7.andNot(var27);
    java.lang.Object var48 = var7.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var45 + "' != '" + "{0}"+ "'", var45.equals("{0}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var48);

  }

  public void test468() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test468");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    int var13 = var2.size();
    var0.or(var2);
    var0.clear();
    int var17 = var0.nextSetBit(10);
    var0.flip(127);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == (-1));

  }

  public void test469() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test469");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    int var18 = var0.cardinality();
    int var20 = var0.nextSetBit(54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == (-1));

  }

  public void test470() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test470");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    BitSet var14 = new BitSet();
    var11.xor(var14);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    var11.and(var19);
    boolean var22 = var0.intersects(var11);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    var23.xor(var26);
    boolean var29 = var26.equals((java.lang.Object)(-1L));
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    int var33 = var30.length();
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    var34.set(100, true);
    boolean var40 = var30.intersects(var34);
    boolean var42 = var30.equals((java.lang.Object)(-1L));
    var30.flip(0);
    int var45 = var30.cardinality();
    boolean var46 = var26.intersects(var30);
    var0.and(var30);
    int var49 = var0.nextSetBit(1);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.flip(90, 54);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == (-1));

  }

  public void test471() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test471");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    boolean var7 = var0.equals((java.lang.Object)'a');
    boolean var8 = var0.isEmpty();
    var0.flip(65, 101);
    BitSet var12 = new BitSet();
    boolean var14 = var12.get(0);
    BitSet var15 = new BitSet();
    var12.xor(var15);
    boolean var18 = var15.equals((java.lang.Object)(-1L));
    BitSet var21 = var15.get(0, 1);
    var21.flip(10, 64);
    var21.clear();
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var29 = var26.length();
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    var30.set(100, true);
    boolean var36 = var26.intersects(var30);
    int var37 = var26.size();
    java.lang.Object var38 = var26.clone();
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    var39.set(100, true);
    var39.set(0, true);
    int var49 = var39.nextSetBit(64);
    BitSet var51 = new BitSet(10);
    var39.or(var51);
    boolean var53 = var26.intersects(var39);
    boolean var54 = var39.isEmpty();
    var21.or(var39);
    boolean var56 = var0.intersects(var39);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var21);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var38);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);

  }

  public void test472() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test472");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var11 = var0.cardinality();
    var0.clear();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.clear(1, 100);
    var0.andNot(var13);
    var0.flip(128, 128);
    int var27 = var0.nextClearBit(55);
    var0.flip(100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 55);

  }

  public void test473() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test473");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    int var17 = var14.length();
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    var18.set(100, true);
    boolean var24 = var14.intersects(var18);
    boolean var26 = var14.equals((java.lang.Object)(-1L));
    var14.flip(0);
    BitSet var31 = var14.get(64, 100);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    int var35 = var32.length();
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    var36.set(100, true);
    boolean var42 = var32.intersects(var36);
    boolean var43 = var31.intersects(var36);
    boolean var44 = var0.equals((java.lang.Object)var31);
    var31.clear();
    java.lang.String var46 = var31.toString();
    var31.flip(54, 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var31);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var46 + "' != '" + "{}"+ "'", var46.equals("{}"));

  }

  public void test474() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test474");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    int var24 = var3.size();
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    var25.set(100, true);
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    int var34 = var31.length();
    BitSet var35 = new BitSet();
    boolean var37 = var35.get(0);
    var35.set(100, true);
    boolean var41 = var31.intersects(var35);
    boolean var43 = var31.equals((java.lang.Object)(-1L));
    var25.or(var31);
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    BitSet var48 = new BitSet();
    var45.xor(var48);
    BitSet var50 = new BitSet();
    boolean var52 = var50.get(0);
    BitSet var53 = new BitSet();
    var50.xor(var53);
    var45.and(var53);
    var53.flip(1);
    boolean var59 = var53.get(100);
    int var60 = var53.size();
    int var61 = var53.cardinality();
    var31.xor(var53);
    var31.flip(0, 128);
    boolean var66 = var31.isEmpty();
    var3.or(var31);
    int var69 = var31.nextClearBit(128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == 128);

  }

  public void test475() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test475");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.set(0, true);
    var0.set(100, false);
    var0.flip(10, 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);

  }

  public void test476() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test476");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var28.get(54);
    var28.set(64, true);
    int var41 = var28.nextSetBit(54);
    int var42 = var28.size();
    boolean var43 = var7.intersects(var28);
    var28.clear();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);

  }

  public void test477() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test477");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.set(0, true);
    int var23 = var13.nextSetBit(64);
    BitSet var25 = new BitSet(10);
    var13.or(var25);
    boolean var27 = var0.intersects(var13);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    boolean var39 = var28.isEmpty();
    int var40 = var28.size();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    int var44 = var41.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    boolean var51 = var41.intersects(var45);
    boolean var52 = var41.isEmpty();
    var41.set(10, 100);
    var28.xor(var41);
    int var58 = var28.nextClearBit(10);
    boolean var59 = var13.intersects(var28);
    BitSet var61 = new BitSet(0);
    var61.clear(1);
    var28.and(var61);
    int var65 = var28.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == 128);

  }

  public void test478() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test478");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var18 = var6.equals((java.lang.Object)(-1L));
    var0.or(var6);
    var0.flip(54, 64);
    BitSet var23 = new BitSet();
    boolean var25 = var23.get(0);
    BitSet var26 = new BitSet();
    boolean var28 = var26.get(0);
    int var29 = var26.length();
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    var30.set(100, true);
    var30.set(0, true);
    var26.andNot(var30);
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    int var43 = var40.length();
    BitSet var44 = new BitSet();
    boolean var46 = var44.get(0);
    var44.set(100, true);
    boolean var50 = var40.intersects(var44);
    boolean var52 = var40.equals((java.lang.Object)(-1L));
    var40.flip(0);
    BitSet var57 = var40.get(64, 100);
    BitSet var58 = new BitSet();
    boolean var60 = var58.get(0);
    int var61 = var58.length();
    BitSet var62 = new BitSet();
    boolean var64 = var62.get(0);
    var62.set(100, true);
    boolean var68 = var58.intersects(var62);
    boolean var69 = var57.intersects(var62);
    boolean var70 = var26.equals((java.lang.Object)var57);
    int var72 = var26.nextSetBit(128);
    var23.or(var26);
    int var75 = var26.nextSetBit(0);
    boolean var76 = var0.equals((java.lang.Object)var75);
    var0.clear();
    int var78 = var0.length();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var57);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var70 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var76 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var78 == 0);

  }

  public void test479() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test479");


    BitSet var1 = new BitSet(100);
    var1.set(1, 101, true);

  }

  public void test480() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test480");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    var3.flip(1, 1);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    int var30 = var27.length();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    var31.set(100, true);
    boolean var37 = var27.intersects(var31);
    boolean var39 = var27.equals((java.lang.Object)(-1L));
    BitSet var42 = var27.get(1, 100);
    var3.or(var27);
    int var44 = var3.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var37 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var42);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);

  }

  public void test481() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test481");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    int var11 = var0.size();
    java.lang.Object var12 = var0.clone();
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    var13.set(100, true);
    var13.set(0, true);
    int var23 = var13.nextSetBit(64);
    BitSet var25 = new BitSet(10);
    var13.or(var25);
    boolean var27 = var0.intersects(var13);
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    BitSet var31 = new BitSet();
    var28.xor(var31);
    BitSet var33 = new BitSet();
    boolean var35 = var33.get(0);
    BitSet var36 = new BitSet();
    var33.xor(var36);
    var28.and(var36);
    boolean var39 = var28.isEmpty();
    int var40 = var28.size();
    BitSet var41 = new BitSet();
    boolean var43 = var41.get(0);
    int var44 = var41.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    boolean var51 = var41.intersects(var45);
    boolean var52 = var41.isEmpty();
    var41.set(10, 100);
    var28.xor(var41);
    int var58 = var28.nextClearBit(10);
    boolean var59 = var13.intersects(var28);
    BitSet var61 = new BitSet(0);
    var61.clear(1);
    var28.and(var61);
    BitSet var65 = new BitSet();
    boolean var67 = var65.get(0);
    var65.set(100, true);
    boolean var72 = var65.equals((java.lang.Object)'a');
    int var73 = var65.length();
    boolean var74 = var61.intersects(var65);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var77 = var61.get(127, 10);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var12);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var40 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == 100);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == 101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var74 == false);

  }

  public void test482() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test482");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    int var12 = var8.nextSetBit(1);
    boolean var14 = var8.get(65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var14 == false);

  }

  public void test483() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test483");


    BitSet var0 = new BitSet();
    BitSet var1 = new BitSet();
    boolean var3 = var1.get(0);
    boolean var4 = var0.equals((java.lang.Object)0);
    int var6 = var0.nextClearBit(0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == 0);

  }

  public void test484() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test484");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    int var5 = var2.length();
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    var6.set(100, true);
    boolean var12 = var2.intersects(var6);
    int var13 = var2.size();
    var0.or(var2);
    var0.clear();
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    boolean var22 = var19.equals((java.lang.Object)(-1L));
    BitSet var25 = var19.get(0, 1);
    var25.flip(10, 64);
    var25.clear();
    java.lang.String var30 = var25.toString();
    var25.clear(100);
    var0.andNot(var25);
    int var34 = var0.length();
    int var36 = var0.nextSetBit(90);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var5 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var25);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var30 + "' != '" + "{}"+ "'", var30.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == (-1));

  }

  public void test485() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test485");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    BitSet var15 = var0.get(1, 100);
    var0.set(100, true);
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    BitSet var22 = new BitSet();
    var19.xor(var22);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    BitSet var27 = new BitSet();
    var24.xor(var27);
    var19.and(var27);
    var19.clear(55);
    var0.or(var19);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var15);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);

  }

  public void test486() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test486");


    BitSet var0 = new BitSet();
    int var1 = var0.length();
    java.lang.Object var2 = var0.clone();
    boolean var4 = var0.get(128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var1 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);

  }

  public void test487() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test487");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    var4.set(0, true);
    var0.andNot(var4);
    var0.flip(64);
    var0.clear(54);
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      BitSet var20 = var0.get(101, 1);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);

  }

  public void test488() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test488");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var0.flip(54);
    BitSet var13 = new BitSet();
    boolean var15 = var13.get(0);
    int var16 = var13.length();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    var17.set(100, true);
    boolean var23 = var13.intersects(var17);
    boolean var25 = var13.equals((java.lang.Object)(-1L));
    var13.flip(0);
    BitSet var30 = var13.get(64, 100);
    BitSet var33 = var13.get(2, 128);
    BitSet var34 = new BitSet();
    boolean var36 = var34.get(0);
    BitSet var37 = new BitSet();
    var34.xor(var37);
    int var39 = var37.length();
    var37.clear();
    boolean var41 = var33.intersects(var37);
    var0.or(var37);
    var0.set(128);
    var0.set(1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var25 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var30);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var33);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);

  }

  public void test489() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test489");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    BitSet var17 = var0.get(64, 100);
    BitSet var20 = var0.get(2, 128);
    int var21 = var20.size();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var17);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var20);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);

  }

  public void test490() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test490");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    int var3 = var0.length();
    BitSet var4 = new BitSet();
    boolean var6 = var4.get(0);
    var4.set(100, true);
    boolean var10 = var0.intersects(var4);
    boolean var12 = var0.equals((java.lang.Object)(-1L));
    var0.flip(0);
    int var15 = var0.length();
    int var16 = var0.cardinality();
    BitSet var17 = new BitSet();
    boolean var19 = var17.get(0);
    BitSet var20 = new BitSet();
    var17.xor(var20);
    boolean var23 = var20.equals((java.lang.Object)(-1L));
    BitSet var26 = var20.get(0, 1);
    var20.clear();
    var0.andNot(var20);
    int var29 = var20.cardinality();
    int var30 = var20.size();
    BitSet var31 = new BitSet();
    boolean var33 = var31.get(0);
    BitSet var34 = new BitSet();
    var31.xor(var34);
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    BitSet var39 = new BitSet();
    var36.xor(var39);
    var31.and(var39);
    int var42 = var31.cardinality();
    var31.clear();
    java.lang.String var44 = var31.toString();
    java.lang.String var45 = var31.toString();
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    var46.set(100, true);
    BitSet var52 = new BitSet();
    boolean var54 = var52.get(0);
    int var55 = var52.length();
    BitSet var56 = new BitSet();
    boolean var58 = var56.get(0);
    var56.set(100, true);
    boolean var62 = var52.intersects(var56);
    boolean var64 = var52.equals((java.lang.Object)(-1L));
    var46.or(var52);
    BitSet var66 = new BitSet();
    boolean var68 = var66.get(0);
    BitSet var69 = new BitSet();
    var66.xor(var69);
    BitSet var71 = new BitSet();
    boolean var73 = var71.get(0);
    BitSet var74 = new BitSet();
    var71.xor(var74);
    var66.and(var74);
    var74.flip(1);
    boolean var80 = var74.get(100);
    int var81 = var74.size();
    int var82 = var74.cardinality();
    var52.xor(var74);
    java.lang.String var84 = var74.toString();
    boolean var85 = var31.equals((java.lang.Object)var74);
    int var86 = var74.length();
    boolean var87 = var74.isEmpty();
    boolean var88 = var20.equals((java.lang.Object)var87);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var3 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var26);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var33 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var44 + "' != '" + "{}"+ "'", var44.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var45 + "' != '" + "{}"+ "'", var45.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var55 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var64 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var80 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var81 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var82 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var84 + "' != '" + "{1}"+ "'", var84.equals("{1}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var85 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var86 == 2);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var87 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var88 == false);

  }

  public void test491() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test491");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.set(1, 100);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    BitSet var17 = new BitSet();
    var14.xor(var17);
    BitSet var19 = new BitSet();
    boolean var21 = var19.get(0);
    BitSet var22 = new BitSet();
    var19.xor(var22);
    var14.and(var22);
    BitSet var25 = new BitSet();
    boolean var27 = var25.get(0);
    BitSet var28 = new BitSet();
    var25.xor(var28);
    BitSet var30 = new BitSet();
    boolean var32 = var30.get(0);
    BitSet var33 = new BitSet();
    var30.xor(var33);
    var25.and(var33);
    boolean var36 = var14.intersects(var25);
    BitSet var37 = new BitSet();
    boolean var39 = var37.get(0);
    BitSet var40 = new BitSet();
    var37.xor(var40);
    boolean var43 = var40.equals((java.lang.Object)(-1L));
    BitSet var44 = new BitSet();
    boolean var46 = var44.get(0);
    int var47 = var44.length();
    BitSet var48 = new BitSet();
    boolean var50 = var48.get(0);
    var48.set(100, true);
    boolean var54 = var44.intersects(var48);
    boolean var56 = var44.equals((java.lang.Object)(-1L));
    var44.flip(0);
    int var59 = var44.cardinality();
    boolean var60 = var40.intersects(var44);
    var14.and(var44);
    java.lang.String var62 = var14.toString();
    var8.and(var14);
    BitSet var64 = new BitSet();
    boolean var66 = var64.get(0);
    var64.flip(1);
    java.lang.Object var69 = var64.clone();
    int var71 = var64.nextSetBit(10);
    boolean var72 = var14.intersects(var64);
    var64.clear(127);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var32 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var50 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var62 + "' != '" + "{}"+ "'", var62.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var66 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var69);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var71 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var72 == false);

  }

  public void test492() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test492");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    int var10 = var7.length();
    BitSet var11 = new BitSet();
    boolean var13 = var11.get(0);
    var11.set(100, true);
    boolean var17 = var7.intersects(var11);
    boolean var19 = var7.equals((java.lang.Object)(-1L));
    var7.flip(0);
    int var22 = var7.cardinality();
    boolean var23 = var3.intersects(var7);
    BitSet var24 = new BitSet();
    boolean var26 = var24.get(0);
    int var27 = var24.length();
    BitSet var28 = new BitSet();
    boolean var30 = var28.get(0);
    var28.set(100, true);
    boolean var34 = var24.intersects(var28);
    boolean var36 = var28.get(54);
    var28.set(64, true);
    int var41 = var28.nextSetBit(54);
    int var42 = var28.size();
    boolean var43 = var7.intersects(var28);
    int var44 = var28.length();
    BitSet var45 = new BitSet();
    boolean var47 = var45.get(0);
    var45.set(100, true);
    BitSet var51 = new BitSet();
    boolean var53 = var51.get(0);
    int var54 = var51.length();
    BitSet var55 = new BitSet();
    boolean var57 = var55.get(0);
    var55.set(100, true);
    boolean var61 = var51.intersects(var55);
    boolean var62 = var45.intersects(var55);
    BitSet var63 = new BitSet();
    boolean var65 = var63.get(0);
    BitSet var66 = new BitSet();
    var63.xor(var66);
    boolean var69 = var66.equals((java.lang.Object)(-1L));
    BitSet var72 = var66.get(0, 1);
    var72.flip(10, 64);
    var72.clear();
    java.lang.String var77 = var72.toString();
    BitSet var78 = new BitSet();
    boolean var80 = var78.get(0);
    BitSet var81 = new BitSet();
    var78.xor(var81);
    boolean var84 = var81.equals((java.lang.Object)(-1L));
    BitSet var87 = var81.get(0, 1);
    var72.xor(var81);
    var55.andNot(var81);
    var28.or(var55);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var13 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var19 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var22 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var26 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var27 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var36 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == 64);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 128);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var44 == 101);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var53 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var54 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var57 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var65 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var72);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var77 + "' != '" + "{}"+ "'", var77.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var80 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var84 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var87);

  }

  public void test493() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test493");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var3.clear();
    BitSet var13 = var3.get(65, 65);
    BitSet var14 = new BitSet();
    boolean var16 = var14.get(0);
    BitSet var17 = new BitSet();
    var14.xor(var17);
    boolean var20 = var17.equals((java.lang.Object)(-1L));
    BitSet var23 = var17.get(0, 1);
    var23.flip(10, 64);
    var23.clear();
    java.lang.String var28 = var23.toString();
    BitSet var29 = new BitSet();
    boolean var31 = var29.get(0);
    BitSet var32 = new BitSet();
    var29.xor(var32);
    boolean var35 = var32.equals((java.lang.Object)(-1L));
    BitSet var38 = var32.get(0, 1);
    var23.xor(var32);
    BitSet var42 = var32.get(0, 65);
    boolean var43 = var3.equals((java.lang.Object)65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var13);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var23);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var28 + "' != '" + "{}"+ "'", var28.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var35 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var38);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var42);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var43 == false);

  }

  public void test494() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test494");


    BitSet var1 = new BitSet(64);
    BitSet var2 = new BitSet();
    boolean var4 = var2.get(0);
    BitSet var5 = new BitSet();
    var2.xor(var5);
    BitSet var7 = new BitSet();
    boolean var9 = var7.get(0);
    BitSet var10 = new BitSet();
    var7.xor(var10);
    var2.and(var10);
    var10.set(1, 100);
    BitSet var16 = new BitSet();
    boolean var18 = var16.get(0);
    BitSet var19 = new BitSet();
    var16.xor(var19);
    BitSet var21 = new BitSet();
    boolean var23 = var21.get(0);
    BitSet var24 = new BitSet();
    var21.xor(var24);
    var16.and(var24);
    BitSet var27 = new BitSet();
    boolean var29 = var27.get(0);
    BitSet var30 = new BitSet();
    var27.xor(var30);
    BitSet var32 = new BitSet();
    boolean var34 = var32.get(0);
    BitSet var35 = new BitSet();
    var32.xor(var35);
    var27.and(var35);
    boolean var38 = var16.intersects(var27);
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    BitSet var42 = new BitSet();
    var39.xor(var42);
    boolean var45 = var42.equals((java.lang.Object)(-1L));
    BitSet var46 = new BitSet();
    boolean var48 = var46.get(0);
    int var49 = var46.length();
    BitSet var50 = new BitSet();
    boolean var52 = var50.get(0);
    var50.set(100, true);
    boolean var56 = var46.intersects(var50);
    boolean var58 = var46.equals((java.lang.Object)(-1L));
    var46.flip(0);
    int var61 = var46.cardinality();
    boolean var62 = var42.intersects(var46);
    var16.and(var46);
    java.lang.String var64 = var16.toString();
    var10.and(var16);
    BitSet var66 = new BitSet();
    boolean var68 = var66.get(0);
    var66.flip(1);
    java.lang.Object var71 = var66.clone();
    int var73 = var66.nextSetBit(10);
    boolean var74 = var16.intersects(var66);
    boolean var75 = var1.intersects(var66);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var4 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var18 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var23 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var29 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var34 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var48 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var52 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var58 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var61 == 1);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var62 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var64 + "' != '" + "{}"+ "'", var64.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var71);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var73 == (-1));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var74 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var75 == false);

  }

  public void test495() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test495");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    boolean var11 = var0.isEmpty();
    var0.clear(10, 10);
    int var15 = var0.cardinality();
    // The following exception was thrown during execution.
    // This behavior will recorded for regression testing.
    try {
      var0.clear(54, 36);
      fail("Expected exception of type java.lang.IndexOutOfBoundsException");
    } catch (java.lang.IndexOutOfBoundsException e) {
      // Expected exception.
    }
    
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var15 == 0);

  }

  public void test496() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test496");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    var0.clear(1, 100);
    int var10 = var0.nextClearBit(65);
    int var11 = var0.cardinality();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var10 == 65);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var11 == 1);

  }

  public void test497() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test497");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    boolean var6 = var3.equals((java.lang.Object)(-1L));
    BitSet var9 = var3.get(0, 1);
    var9.flip(10, 64);
    var9.clear();
    java.lang.String var14 = var9.toString();
    var9.clear(100);
    var9.clear(2, 100);
    java.lang.Object var20 = var9.clone();
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var6 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var9);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var14 + "' != '" + "{}"+ "'", var14.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var20);

  }

  public void test498() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test498");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    BitSet var3 = new BitSet();
    var0.xor(var3);
    BitSet var5 = new BitSet();
    boolean var7 = var5.get(0);
    BitSet var8 = new BitSet();
    var5.xor(var8);
    var0.and(var8);
    var8.flip(1);
    BitSet var13 = new BitSet();
    var8.or(var13);
    var8.clear(64, 64);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    int var31 = var18.cardinality();
    java.lang.String var32 = var18.toString();
    var8.or(var18);
    var8.set(54, false);
    var8.flip(128);
    BitSet var39 = new BitSet();
    boolean var41 = var39.get(0);
    int var42 = var39.length();
    BitSet var43 = new BitSet();
    boolean var45 = var43.get(0);
    var43.set(100, true);
    boolean var49 = var39.intersects(var43);
    boolean var51 = var39.equals((java.lang.Object)(-1L));
    var39.flip(0);
    BitSet var56 = var39.get(64, 100);
    BitSet var57 = new BitSet();
    boolean var59 = var57.get(0);
    int var60 = var57.length();
    BitSet var61 = new BitSet();
    boolean var63 = var61.get(0);
    var61.set(100, true);
    boolean var67 = var57.intersects(var61);
    boolean var68 = var56.intersects(var61);
    boolean var69 = var8.intersects(var61);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var7 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var31 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue("'" + var32 + "' != '" + "{}"+ "'", var32.equals("{}"));
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var41 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var45 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var49 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var51 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var56);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var59 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var60 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var63 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var67 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var68 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var69 == false);

  }

  public void test499() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test499");


    BitSet var0 = new BitSet();
    boolean var2 = var0.get(0);
    var0.set(100, true);
    BitSet var6 = new BitSet();
    boolean var8 = var6.get(0);
    int var9 = var6.length();
    BitSet var10 = new BitSet();
    boolean var12 = var10.get(0);
    var10.set(100, true);
    boolean var16 = var6.intersects(var10);
    boolean var17 = var0.intersects(var10);
    BitSet var18 = new BitSet();
    boolean var20 = var18.get(0);
    int var21 = var18.length();
    BitSet var22 = new BitSet();
    boolean var24 = var22.get(0);
    var22.set(100, true);
    boolean var28 = var18.intersects(var22);
    boolean var30 = var18.equals((java.lang.Object)(-1L));
    var18.flip(0);
    BitSet var35 = var18.get(64, 100);
    BitSet var36 = new BitSet();
    boolean var38 = var36.get(0);
    int var39 = var36.length();
    BitSet var40 = new BitSet();
    boolean var42 = var40.get(0);
    var40.set(100, true);
    boolean var46 = var36.intersects(var40);
    boolean var47 = var35.intersects(var40);
    var35.clear(64, 64);
    var10.andNot(var35);
    var35.flip(0, 128);
    int var56 = var35.nextClearBit(54);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var2 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var8 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var9 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var12 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var16 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var17 == true);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var20 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var21 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var24 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var28 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var30 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertNotNull(var35);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var38 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var39 == 0);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var42 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var46 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var47 == false);
    
    // Regression assertion (captures the current behavior of the code)
    assertTrue(var56 == 128);

  }

  public void test500() throws Throwable {

    if (debug) System.out.printf("%nRandoopTest0.test500");


    BitSet var1 = new BitSet(36);

  }

}
